// //#region 本地数据仓库

// /**
//  * 用于本地缓存的数据仓库
//  */
// const session = {
//     /**
//      * 系统配置对象，部分数值从服务端实时获取
//      */
//     config: {
//         maxVillageNum: 10,
//         Speed: 1,
//         Output: 1,
//         exchange: 1,
//         baseInfo: {
//             gradingDesc: [
//                 " 已经有建筑在建造中。",
//                 " 资源不足。",
//                 " 粮食产量不足: 需要先建造一个农场。",
//                 " 已经升级到最高级别。",
//                 " 即将建造完毕。",
//                 " 所需资源超过你的仓库储量，请先升级你的仓库。",
//                 " 所需粮食超过你的谷仓储量，请先升级你的谷仓。",
//                 " 无法建造。"
//             ],
//         },

//         dyncHint: [
//             "你获得了宝物$0$($1$)",
//             "对村庄$0$的速建支援",
//             "缩短了村庄$0$的$1$分钟的建设时间",
//             "对村庄$0$的建设没有起到任何作用",
//             "$0$对$1$的暗杀行动",
//             "本次暗杀行动使对方英雄的生命值由$0$降至$1$",
//             "$0$对$1$的破坏行动",
//             "$0$侦查$1$",
//             "对村庄$0$的支援被攻击",
//             "村庄忠诚度从$0$降到$1$",
//             "来自于$0$的村民已经决定接受你的统治",
//             "你在今天的$0$将攒够足够升级的资源",//时间
//             "你在$0$天后的$1$将攒够足够升级的资源",//时间
//             "要塞$0$已经决定加入你的联盟",
//             "要塞$0$被你征服，但无法加入你的联盟"
//         ],

//         gradingDesc: [
//                     " 已经有建筑在建造中。",
//                     " 资源不足。",
//                     " 粮食产量不足: 需要先建造一个农场。",
//                     " 已经升级到最高级别。",
//                     " 即将建造完毕。",
//                     " 所需资源超过你的仓库储量，请先升级你的仓库。",
//                     " 所需粮食超过你的谷仓储量，请先升级你的谷仓。",
//                     " 无法建造。"
//         ],

//         getHint(ind, param) {
//             let retVal = this.dyncHint[ind];
//             if(param!=null)
//             {
//                 for(let i=0;i<param.length;i++)
//                 {
//                     retVal = retVal.replace("$"+i.toString()+"$",param[i]);
//                 }
//             }
//             return retVal;
//         },

//         /**
//          * 返回初始村庄中士兵字符串
//          * @param {*} race 种族，分为罗马、高卢、日耳曼三种
//          * @returns 士兵字符串
//          */
//         getInitSoldier(race)
//         {
//             let retValue = "";
//             switch (race)
//             {
//                 case raceType.Rome://罗马
//                     retValue = "1,0;2,0;3,0;4,0;5,0;6,0;7,0;8,0;9,0;10,0";
//                     break;

//                 case raceType.Teuton://日耳曼
//                     retValue = "11,0;12,0;13,0;14,0;15,0;16,0;17,0;18,0;19,0;20,0";
//                     break;

//                 case raceType.Gaul://高卢
//                     retValue = "21,0;22,0;23,0;24,0;25,0;26,0;27,0;28,0;29,0;30,0";
//                     break;

//                 default://自然界
//                     retValue = "31,0;32,0;33,0;34,0;35,0;36,0;37,0;38,0;39,0;40,0";
//                     break;
//             }
//             return retValue;
//         },
//     },

//     /**
//      * 任务配置表
//      */
//     tasks: {
//         cur: 0,
//         curLayer: 0, //跑环指针
//         list: TaskStaticList,
//         get: function(id) {
//             return TaskConfig[id];
//         },
//         index: function(id) {
//             return TaskStaticList.indexOf(TaskConfig[id]);
//         },
//         canShow(ti) { //查看该任务是否可显示
//             if(ti.status == 1) { //待领奖的任务一定可见
//                 return true;
//             }

//             if(ti.status == 2) { //已领奖但尚未重置的任务不可见
//                 return false;
//             }

//             let layer = parseInt(ti.layer);
//             if(this.typeOf(ti.id) == '循环任务') {
//                 if(layer != session.tasks.curLayer) {
//                     return false;
//                 }
//             } else {
//                 if(layer > 0) {
//                     for(let it of this.list) {
//                         if(this.typeOf(it.id) == this.typeOf(ti.id) && parseInt(it.layer) == layer-1 && !parseInt(it.status)) {
//                             return false;
//                         }
//                     }
//                 }
//             }

//             return true;
//         },
//         typeOf(id) { //获取任务类型 1主线 2日常 3循环
//             let tp = (parseInt(id)/1000)|0;
//             switch(tp) {
//                 case 1: return '主线任务';
//                 case 2: return '日常任务';
//                 case 3: return '循环任务';
//                 default: return '未知任务';
//             }
//         }
//     },
//     /**
//      * 记录当前路由
//      * @param {*} type      操作类型
//      * @param {*} params    操作参数
//      * @param {*} del       需要排除的操作参数
//      */
//     setLoc(type, params, del) {
//         let ls = type.split('&');
//         type = ls.shift();
        
//         params = params || {};
//         for(let it of ls) {
//             let kv = it.split('=');
//             params[kv[0]] = kv[1];
//         }

//         del = del || [];
//         if(!Array.isArray(del)) {
//             del = [del]
//         }

//         for(let item of del) {
//             delete params[item];
//         }

//         this.curPage = type;
//         this.curLoc = Object.keys(params).reduce((sofar, cur)=>{
//             sofar += `&${cur}=${params[cur]}`;
//             return sofar;
//         }, type);

//         //打印当前路由
//         console.log('当前路由:', this.curLoc);

//         return {type, params};
//     },
//     /***
//      * 当前操控的村庄标识
//      * @description 当前登录用户名下可能有多个村庄，必须能唯一确定当前操控村庄，以便正确提交并处理各项命令
//      */
//     curVid: 0,
//     curLoc: 'dorf1',
//     /**
//      * 当前登录用户
//      */
//     /**
//      * 当前操控的村庄对象
//      * @returns {villageObj}
//      */
//     get vo() {
//         for(let it of this.uo.villageObjList) {
//             if(it.zoneId == this.curVid) {
//                 return it;
//             }
//         }
//         return new villageObj();
//     },
//     /**
//      * 本地缓存的地图数据
//      */
//     villageList: new Map(),
//     /**
//      * 从本地缓存取村庄对象，或者以网格对象作为平替
//      * @param {*} zid 
//      * @returns 
//      */
//     getVillageByZid(zid) {
//         if(zid == this.vo.zoneId) {//优先取本村
//             return this.vo;
//         }

//         for(let it of this.uo.villageObjList) { //再取领主下属村庄
//             if(it.zoneId == zid) {
//                 return it;
//             }
//         }

//         if(this.villageList.has(zid)) { //取地图缓存数据
//             return this.villageList.get(zid);
//         }

//         return {uid: 0};
//     },
//     /**
//      * 缓存网格信息
//      * @param {*} vo 
//      */
//     setVillageByZid(vo) {
//         this.villageList.set(vo.zoneId, vo);
//     },
//     /**
//      * 填充第三方村庄对象的部分属性
//      * @param {*} params 
//      */
//     initThirdVillage(params) {
//         this.kvo.user.curVillage = params.curVillage;
//         this.kvo.user.allyId = params.user.allyId;
//         this.kvo.user.allyName = params.user.allyName;
//         this.kvo.user.allyCutName = params.user.allyCutName;
//         this.kvo.user.openid = params.user.openid;
//         this.kvo.user.uInfo = params.user.uInfo;
//         this.kvo.user.uInfo.raceName = raceName[this.kvo.user.uInfo.race];
//         this.kvo.user.uInfo.uTypeName = userTypeName[this.kvo.user.uInfo.uType];
//         this.kvo.user.uInfo.uTypeName = userTypeName[this.kvo.user.uInfo.uType];

//         this.kvo.init(params);
//     },
//     /**
//      * 服务端对客户端的信息同步刷新函数
//      * @param {*} params 
//      */
//     initMain(params) {
//         session.config.Speed = params.config.Speed;
//         session.config.Output = params.config.Output;
//         session.config.exchange = params.config.exchange;
        
//         if(params.scs) {
//             simCityManager.init(params.scs);
//         }

//         this.curVid = params.curVid;
//         this.square = params.square; //地图半径
//         this.uo.wid = params.user.wid; //地下城编号，0表示主城
//         this.uo.allyId = params.user.allyId;
//         this.uo.allyName = params.user.allyName;
//         this.uo.allyCutName = params.user.allyCutName;
//         this.uo.effectMgr.init(params.user.effects);
//         this.uo.diamond = params.user.diamond;
//         this.uo.uInfo = params.user.uInfo;
//         this.uo.uInfo.raceName = raceName[this.uo.uInfo.race];
//         this.uo.uInfo.uTypeName = userTypeName[this.uo.uInfo.uType];
//         this.uo.villageObjList = params.villageObjList.reduce((sofar,cur)=>{
//             let vi = new villageObj();
//             vi.user = this.uo;
//             Object.assign(vi, cur);

//             sofar.push(vi);
//             return sofar;
//         }, []);
//         this.uo.curVillage = params.curVillage;
//         this.uo.openid = params.user.openid;
//         this.vo.init(params);
//     },
//     /**
//      * 登录用户标识字符串
//      */
//     OpenId: 0,
// };
// //#endregion

// /**
//  * 建筑物升级所需资源
//  * @param {*} bType     建筑物类型
//  * @param {*} bGrade    建筑物级别
//  * @param {*} rType     资源类型(木;泥;铁;粮;粮耗)
//  * @returns 
//  */
// function buildingReqRes(bType, bGrade, rType) {
//     if (rType == 5) {
//         return bProperty[bType][bGrade][rType];
//     } else {
//         return (bProperty[bType][bGrade][rType] * session.config.exchange);
//     }
// }

// //#region 联盟相关

// /**
//  * 联盟成员对象
//  */
// class AllyUserInfo
// {
//     /**
//      * 用户Id
//      */
//     UserId;
//     /**
//      * 用户名
//      */
//     UserName;
//     /**
//      * 联盟Id
//      */
//     AllyId;
//     /**
//      * 联盟名称
//      */
//     AllyName;
//     /**
//      * 最后在线时间
//      */
//     LastOnline;
//     /**
//      * 人口数
//      */
//     People;
//     /**
//      * 村庄数
//      */
//     VillageNum;
//     /**
//      * 盟内头衔
//      */
//     AllyTitle;
//     /**
//      * 联盟权限
//      */
//     AllyAuthority;
//     /**
//      * 判断当前用户是否拥有某项权限
//      * @param {*} aloc 权限代号
//      * @returns true有 false无
//      */
//     chkAuthority(aloc) {
//         let loc = parseInt(aloc);
//         if (loc < 0 || loc > 10) {
//             return false;
//         }
//         return this.AllyAuthority[loc] == '1' ? true : false;
//     }
// }

// class Ally 
// {
//     static getAllyInvite() {
//         return [];
//     }
// }

// class allyObject
// {
//     async getAllyReportList() {
//         return [];
//     }
// }

// //#endregion

// //#region 地图管理相关

// /**
//  * 计算商人两点间移动需要的时间
//  * @param {*} z1 
//  * @param {*} z2 
//  * @param {*} sph 
//  * @returns 
//  */
// function MoveTime(z1, z2, sph) 
// {
//     let distance = zoneMap.distance(z1,z2);
//     let ret = (((distance/sph)*3600))|0;
//     return ret;
// }

// /**
//  * 计算军队两点间移动需要的时间
//  * @param {*} z1 
//  * @param {*} z2 
//  * @param {*} sph 
//  * @param {*} sph_basic 
//  * @returns 
//  */
// function MoveTime_army(z1, z2, sph, sph_basic) {
//     if (sph_basic == 0) {
//         sph_basic = 3;
//     }

//     let distance = zoneMap.distance(z1,z2);

//     let ret=0;
//     let baseDistance = 30.0 / session.config.Speed;

//     if(distance > baseDistance) {
//         ret = Math.max(1, 3600*((distance - baseDistance) / sph + baseDistance / sph)) | 0;
//     } else {
//         ret = Math.max(1, 3600*(distance / sph_basic)) | 0;
//     }
//     return ret;
// }

// //#endregion

// //#region 用户和村庄管理

// /**
//  * 技能特效管理器
//  */
// class EffectManager {
//     constructor(){
//         this.effectList = {};
//     }

//     init($val) {
//         if(typeof $val == 'object') {
//             this.effectList = $val;
//         } else  if($val != null && $val != '') {
//             //读取配置表并形成特权对象列表
//             for(let item of $val.split(';')) {
//                 this.AddItem(this.makeItem(item));
//             }
//         }
//     }

//     /**
//      * 根据字符串构造一个效果对象
//      * @param string $val
//      * @return {EffectObject}
//      */
//     makeItem($val) {
//         let $items = $val.split(',');
//         if($items.length >= 2){
//             return new EffectObject(parseInt($items[0]), parseFloat($items[1]));
//         }
//         return new EffectObject(0, 0);
//     }

//     /**
//      * 将技能列表转化为数组
//      */
//     toArray(){
//         return Object.keys(this.effectList).reduce((sofar,cur)=>{
//             sofar.push(this.effectList[cur]);
//             return sofar;
//         },[]);
//     }

//     /**
//      * 清空全部现有效果
//      */
//     Clear() {
//         this.effectList = {};
//         return this;
//     }

//     /**
//      * 叠加其他特权管理器, 支持链式操作
//      * @param $em
//      */
//     Add($em) {
//         if($em.constructor == String) {
//             $em.split(';').map(item=>{
//                 let _eff = item.split(',');
//                 if(_eff.length >= 2){
//                     this.AddItem(new EffectObject(parseInt(_eff[0]), parseFloat(_eff[1])));
//                 }
//             });
//         } else {
//             Object.keys($em.effectList).map(key=>{
//                 if (!this.effectList[key]) {//之前不存在该种特权
//                     this.effectList[key] = $em.effectList[key];
//                 } else {
//                     this.effectList[key].Add($em.effectList[key]);
//                 }
//             });
//         }
//         return this;
//     }

//     /**
//      * 传入特权类型、特权初始值, 累计所有特权加持效果，得到加持后的特权最终值
//      * @param effect
//      * @param oriValue
//      * @return {*}
//      */
//     CalcFinallyValue(effect, oriValue) {
//         let $type = effect.type;
//         let $mode = effect.mode;

//         if (!this.effectList[$type]) {
//             return oriValue;
//         }

//         switch ($mode) {
//             case 1:
//                 return oriValue + this.effectList[$type].value;
//             case 2:
//                 return oriValue - this.effectList[$type].value;
//             case 3:
//                 return oriValue * (1 + this.effectList[$type].value);
//             case 4:
//                 return oriValue * (1 - this.effectList[$type].value);
//         }
//         return oriValue;
//     }

//     /**
//      * 叠加单个特权效果对象 支持链式操作
//      * @param $eo
//      * @return this
//      */
//     AddItem($eo) {
//         if (!this.effectList[$eo.type]) {
//             this.effectList[$eo.type] = $eo;
//         } else {
//             this.effectList[$eo.type].Add($eo);
//         }
//         return this;
//     }
// }

// class EffectObject {
//     constructor($eType, $eValue, $expired = 0) {
//         this.type = $eType;
//         this.value = $eValue;
//         this.expired = $expired;
//     }

//     /**
//      * 剩余的有效时长
//      * @returns {number}
//      */
//     getLeftTime(){
//         let $cur = now();
//         return this.expired > $cur ? this.expired - $cur : 0;
//     }

//     /**
//      * 设置当前时间起，向后延长的有效时长（秒）
//      * @param $len
//      */
//     setLeftTime($len){
//         this.expired = now() + $len;
//     }

//     /**
//      * @param $eo
//      * 叠加相同类型的特权效果对象
//      */
//     Add($eo) {
//         if(this.type == $eo.type){
//             if(!!!this.expired || this.expired == 0){//永久有效的效果，数值叠加
//                 this.value += $eo.value;
//             } else {//有效期相叠加
//                 this.setLeftTime(this.getLeftTime() + $eo.getLeftTime());
//             }
//         }
//     }
// }

// /**
//  * 用户类
//  */
// class userObj {
//     constructor() {
//     }

//     /**
//      * 用户当前所处的地下城
//      */
//     get sc() {
//         return simCityManager.getSimCityObj(this.wid);
//     }
//     /**
//      * 下属村庄列表
//      */
//     villageObjList = [];
//     /**
//      * 下属村庄ID列表
//      */
//     get villageIdList() {
//         return this.villageObjList.reduce((sofar, cur)=>{
//             sofar.push(cur.zoneId);
//             return sofar;
//         }, []);
//     }
//     uInfo = {
//         uType: 0,
//         raceName: '人族', 
//         uTypeName: '武士',
//         race: 1,
//         uid: 0,
//     };
//     allyId = 0;
//     allyName = '';
//     allyCutName = '';

//     effectMgr = new EffectManager();
// }

// /**
//  * 村庄类
//  */
// class villageObj
// {
//     constructor() {
//         /**
//          * 协防的军队（已到达的）外村驻本村协防军队列表，列表中每个元素是army类型的对象
//          */
//         this.soldiersInList = [];
//         /**
//          * 协防的军队（未到达的）外村出发攻击、支援本村的军队，不包括外村支援返回原村的情况
//          */
//         this.soldiersInNotArrivedList = [];
//         /**
//          * 驻外的军队已到达的 本村驻外村协防士兵列表，列表中每个元素是army类型的对象，指已经到达对方村落的部队
//          */
//         this.soldiersOutList = [];
//         /**
//          * 驻外的军队未到达的 本村出发（攻击或者支援）或者返回的、尚未到达的军队
//          */
//         this.soldiersOutNotArrivedList = [];
//     }

//     /**
//      * 判断兵种升级是否可以执行
//      * @param {soldier} sd        兵种类型
//      * @param {*} gType     0:升级攻击 1:升级防御
//      * @returns 动作执行结果
//      */
//     GradingSoldier(sd, gType)
//     {
//         if (sd.study == false) {
//             return -1;//尚未研发
//         }

//         let st;
//         if (gType == 0) {
//             if (sd.aGrade == 20) {//已经升级到最高级
//                 return 1;//升级已完成
//             }
//             if (this.res.wood_reserve < sd.curGradingWood(0)) {
//                 return -1;//资源不足
//             }
//             if (this.res.mud_reserve < sd.curGradingMud(0)) {
//                 return -1;//资源不足
//             }
//             if (this.res.iron_reserve < sd.curGradingIron(0)) {
//                 return -1;//资源不足
//             }
//             if (this.res.food_reserve < sd.curGradingFood(0)) {
//                 return -1;//资源不足
//             }

//             st = ((Date.now()/1000)|0) + ((sd.curAGradingTime / this.user.effectMgr.CalcFinallyValue(em_Effect_Comm.grading, 1.0))|0);
//         } else {
//             if (sd.dGrade == 20) {//已经升级到最高级别
//                 return 1;//升级已完成
//             }
//             if (this.res.wood_reserve < sd.curGradingWood(1)) {
//                 return -1;//资源不足
//             }
//             if (this.res.mud_reserve < sd.curGradingMud(1)) {
//                 return -1;//资源不足
//             }
//             if (this.res.iron_reserve < sd.curGradingIron(1)) {
//                 return -1;//资源不足
//             }
//             if (this.res.food_reserve < sd.curGradingFood(1)) {
//                 return -1;//资源不足
//             }

//             st = ((Date.now()/1000)|0) + ((sd.curDGradingTime / this.user.effectMgr.CalcFinallyValue(em_Effect_Comm.grading, 1.0))|0);
//         }

//         return 0;
//     }

//     importArmyList() {
//         let soldiersOutNotArrivedList = this.soldiersOutNotArrivedList.reduce((sofar,cur) => {
//             let am = new army();
//             am.importInfo(cur);
//             sofar.push(am);

//             return sofar;
//         }, [])
//         let soldiersInNotArrivedList = this.soldiersInNotArrivedList.reduce((sofar,cur) => {
//             sofar.push(new army().importInfo(cur));
//             return sofar;
//         }, [])
//         let soldiersInList = this.soldiersInList.reduce((sofar,cur) => {
//             sofar.push(new army().importInfo(cur));
//             return sofar;
//         }, [])
//         let soldiersOutList = this.soldiersOutList.reduce((sofar,cur) => {
//             sofar.push(new army().importInfo(cur));
//             return sofar;
//         }, [])

//         return [soldiersOutNotArrivedList, soldiersInNotArrivedList, soldiersInList, soldiersOutList];
//     }
//     /**
//      * 判断当前是否有研发事件，因为科技研发同时只能有一个，因此需要先检测当前是否有科技事件
//      * @returns 0表示无研发任务，其它值表示当前正在研发的士兵类型
//      */
//     hasStudying() {
//         let $handle = 0;
//         let retVal = 0;
//         let dtime = ((Date.now()/1000)|0);

//         for (let ev of session.vo.eventList) {
//             if (ev.eZone == this.zoneId && ev.eType == EventType.study) {
//                 $handle = ev.eHandle,
//                 retVal = parseInt(ev.eParam);
//                 dtime = ev.eStartTime;
//                 break;
//             }
//         }

//         return {
//             $handle,
//             $ret: retVal,
//             $time: dtime,
//         }
//     }
//     /**
//      * 判断能否研发，执行研发动作，写入研发事件
//      * @param {*} sType     士兵类型
//      * @returns 0能研发 -1科技不足 -2资源不足
//      */
//     studying(sType) {
//         //科技树判断
//         switch (sType) {
//             case SoldierType.h_1jinwei://禁卫，军械库1，研究院1
//                 if (this.bManager.getBuildingByGid(buildingType.B13_Armoury).grade < 1 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 1)
//                     return -1;

//                 break;

//             case SoldierType.h_2diguo://帝国，铁匠铺1，研5
//                 if (this.bManager.getBuildingByGid(buildingType.B12_Blacksmith).grade < 1 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 5)
//                     return -1;

//                 break;

//             case SoldierType.h_3shijie://使节骑士，马厩1，研5
//                 if (this.bManager.getBuildingByGid(buildingType.B20_Stable).grade < 1 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 5)
//                     return -1;

//                 break;

//             case SoldierType.h_4diqi://帝国骑士，马厩5,研5
//                 if (this.bManager.getBuildingByGid(buildingType.B20_Stable).grade < 5 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 5)
//                     return -1;

//                 break;

//             case SoldierType.h_5jiangqi://将军骑士，马厩10，研5
//                 if (this.bManager.getBuildingByGid(buildingType.B20_Stable).grade < 10 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 5)
//                     return -1;

//                 break;

//             case SoldierType.h_6chongche://冲撞车，工场1，研10
//                 if (this.bManager.getBuildingByGid(buildingType.B21_Workshop).grade < 1 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 10)
//                     return -1;

//                 break;

//             case SoldierType.h_7toushi://火焰投石车，工场10，研15
//                 if (this.bManager.getBuildingByGid(buildingType.B21_Workshop).grade < 10 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 15)
//                     return -1;

//                 break;

//             case SoldierType.h_8canyi://忽悠，集结点10，研20
//                 if (this.bManager.getBuildingByGid(buildingType.B16_RallyPoint).grade < 10 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 20)
//                     return -1;

//                 break;

//             case SoldierType.m_1jianshi://剑士，铁匠铺1，研1
//                 if (this.bManager.getBuildingByGid(buildingType.B12_Blacksmith).grade < 1 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 1)
//                     return -1;

//                 break;

//             case SoldierType.m_2tanlu://探路者，马厩1，研5
//                 if (this.bManager.getBuildingByGid(buildingType.B20_Stable).grade < 1 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 5)
//                     return -1;

//                 break;

//             case SoldierType.m_3leifa://雷法，马厩3，研5
//                 if (this.bManager.getBuildingByGid(buildingType.B20_Stable).grade < 3 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 5)
//                     return -1;

//                 break;

//             case SoldierType.m_4deluyi://德鲁伊，马厩5，研5
//                 if (this.bManager.getBuildingByGid(buildingType.B20_Stable).grade < 5 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 5)
//                     return -1;

//                 break;

//             case SoldierType.m_5haidun://海顿，马厩10，研15
//                 if (this.bManager.getBuildingByGid(buildingType.B20_Stable).grade < 10 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 15)
//                     return -1;

//                 break;

//             case SoldierType.m_6chongche://冲车，工场1，研10
//                 if (this.bManager.getBuildingByGid(buildingType.B21_Workshop).grade < 1 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 10)
//                     return -1;

//                 break;

//             case SoldierType.m_7toushi://投石车，工场10，研15
//                 if (this.bManager.getBuildingByGid(buildingType.B21_Workshop).grade < 10 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 15)
//                     return -1;

//                 break;

//             case SoldierType.m_8canyi://忽悠，集结点10，研20
//                 if (this.bManager.getBuildingByGid(buildingType.B16_RallyPoint).grade < 10 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 20)
//                     return -1;

//                 break;

//             case SoldierType.x_1maobing://矛兵，研1
//                 if (this.bManager.getBuildingByGid(buildingType.B19_Barracks).grade < 1 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 1)
//                     return -1;

//                 break;

//             case SoldierType.x_2futou://斧头，铁匠铺1，研3
//                 if (this.bManager.getBuildingByGid(buildingType.B12_Blacksmith).grade < 1 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 3)
//                     return -1;

//                 break;

//             case SoldierType.x_3zhencha://侦查，中心大楼5，研1
//                 if (this.bManager.getBuildingByGid(buildingType.B15_MainBuilding).grade < 5 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 1)
//                     return -1;

//                 break;

//             case SoldierType.x_4xiake://侠客，马厩3，研5
//                 if (this.bManager.getBuildingByGid(buildingType.B20_Stable).grade < 3 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 5)
//                     return -1;

//                 break;

//             case SoldierType.x_5riqi://日骑，马厩10，研15
//                 if (this.bManager.getBuildingByGid(buildingType.B20_Stable).grade < 10 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 15)
//                     return -1;

//                 break;

//             case SoldierType.x_6chongche://冲车，工场1，研10
//                 if (this.bManager.getBuildingByGid(buildingType.B21_Workshop).grade < 1 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 10)
//                     return -1;

//                 break;

//             case SoldierType.x_7toushi://投石车，工场10，研15
//                 if (this.bManager.getBuildingByGid(buildingType.B21_Workshop).grade < 10 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 15)
//                     return -1;

//                 break;

//             case SoldierType.x_8canyi://忽悠，集结点5，研20
//                 if (this.bManager.getBuildingByGid(buildingType.B16_RallyPoint).grade < 5 || this.bManager.getBuildingByGid(buildingType.B22_Academy).grade < 20)
//                     return -1;

//                 break;
//         }

//         //计算并扣减研发资源
//         let sd = this.soldiers.getSoldier(sType);
//         if (sd.study == false) {
//             if (this.res.wood_reserve < sd.study_wood
//                 || this.res.mud_reserve < sd.study_mud
//                 || this.res.iron_reserve < sd.study_iron
//                 || this.res.food_reserve < sd.study_food)
//             {
//                 return -2;
//             }
//         }
//         return 0;
//     }
//     /**
//      * 属性字段：村庄总军队
//      */
//     get totalArmy()
//     {
//         let ai = new totoalArmyInfo();

//         for (let si of this.soldiers.soldiers) {
//             if (si.sType >= 1 && si.sType <= 40) {
//                 ai.sList[si.sType - 1].addSoldier(si.soldierString);
//             }
//         }

//         for (let am of this.soldiersInList) {
//             let ar = new army();
//             ar.soldiersString = am.soldiersString;
//             for (let si of ar.soldiers) {
//                 if (si.sType >= 1 && si.sType <= 40) {
//                     ai.sList[si.sType - 1].addSoldier(si.soldierString);
//                 }
//             }
//         }

//         return ai;
//     }
//     oasisList = [];
//     parentId = 0;
//     parentName = '';
//     get uid() {
//         if(!!this.user) {
//             return this.user.uInfo.uid;
//         }
//         return this._ownerId;
//     }
//     set uid(value) {
//         if(!this.user) {
//             this._ownerId = value;
//         }
//     }
//     _ownerId = 0;
//     user = new userObj();
//     typeId = 21;
//     zoneId = 0;
//     xId = 0;
//     yId = 0;
//     villageName = '无人村庄';
//     villageImg = 1;
//     people = 0;
//     canTrainedBuilder = 0;
//     /**
//      * 绿洲对资源增长产生的效果，返回整型数组，按照0-3分别索引到木泥铁粮四种增长效果。
//      */
//     get resAdded()
//     {
//         let radd = [0, 0, 0, 0];
//         switch (this.typeId)
//         {
//             case 1:
//                 radd[VillageResType.res_food] = 50;//粮
//                 break;
//             case 2:
//                 radd[VillageResType.res_wood] = 50;//木
//                 break;
//             case 3:
//                 radd[VillageResType.res_iron] = 50;//铁
//                 break;
//             case 4:
//                 radd[VillageResType.res_mud] = 50;//石
//                 break;
//             case 5:
//                 radd[VillageResType.res_food] = 25;//粮
//                 radd[VillageResType.res_mud] = 25;//石
//                 break;
//             case 6:
//                 radd[VillageResType.res_food] = 25;//粮
//                 radd[VillageResType.res_iron] = 25;//铁
//                 break;
//             case 7:
//                 radd[VillageResType.res_food] = 25;//粮
//                 radd[VillageResType.res_wood] = 25;//木
//                 break;
//             case 8:
//                 radd[VillageResType.res_wood] = 25;//木
//                 break;
//             case 9:
//                 radd[VillageResType.res_iron] = 25;//铁
//                 break;
//             case 10:
//                 radd[VillageResType.res_mud] = 25;//石
//                 break;
//             case 11:
//                 radd[VillageResType.res_food] = 25;//粮
//                 break;
//         }
//         return radd;
//     }
//     /**
//      * 木头加成
//      */
//     get woodAdded()
//     {
//         if (this.typeId > 0 && this.typeId < 20) {
//             return this.resAdded[0];
//         } else {
//             return 0;
//         }
//     }
//     /**
//      * 泥巴加成
//      */
//     get mudAdded()
//     {
//         if (this.typeId > 0 && this.typeId < 20) {
//             return this.resAdded[1];
//         } else {
//             return 0;
//         }
//     }
//     /**
//      * 铁矿加成
//      */
//     get ironAdded()
//     {
//         if (this.typeId > 0 && this.typeId < 20)
//         {
//             return this.resAdded[2];
//         }
//         else
//             return 0;
//     }
//     /**
//      * 粮食加成
//      */
//     get foodAdded()
//     {
//         if (this.typeId > 0 && this.typeId < 20)
//         {
//             return this.resAdded[3];
//         }
//         else
//             return 0;
//     }
//     buildInfo = {
//         trainedBuilder: 0,
//     };

//     static _civilRequest = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1397000];
//     civilRequest(vilCount) {
//         if (vilCount < 0)
//             return 0;

//         return villageObj._civilRequest[Math.min(vilCount, 19)];
//     };
//     canCreateNewVillage() {
//         if (this.user.villageObjList.length >= session.config.maxVillageNum) {
//             return 5;
//         }

//         if (this.user.uInfo.civil < this.civilRequest(this.user.villageObjList.length)) {
//             return 1;
//         }

//         if (this.bManager.getBuildingByGid(buildingType.B16_RallyPoint).grade <= 0) {
//             return 3;
//         }

//         if (this.buildInfo.trainedBuilder < 3) {
//             return 2;
//         }

//         if (this.res.food_reserve < 750 || this.res.wood_reserve < 750 || this.res.mud_reserve < 750 || this.res.iron_reserve < 750) {
//             return 4;
//         }

//         return 0;
//     }
//     bManager = new bManager();
//     soldiers = new army(this);
//     init = (params) => {
//         if(!params) {
//             params = {};
//         }

//         this.zoneId = params.zoneId;
//         this.typeId = params.typeId;

//         let xy = zoneMap.getXyByZoneId(params.zoneId);
//         this.xId = xy[0];
//         this.yId = xy[1];

//         this.villageName = params.villageName || '新的村庄';
//         this.faithful = params.faithful || 0;
//         this.res = params.res || {
//             comm_max_reserve: 1000,
//             food_max_reserve: 1000,
//             wood_output: 3600,
//             wood_reserve: 100,
//             food_output: 3600,
//             food_reserve: 100,
//             mud_output: 3600,
//             mud_reserve: 100,
//             iron_output: 3600,
//             iron_reserve: 100,
//             parent: {
//                 Consume: 5000,
//             },
//         };
//         this.buildInfo = params.buildInfo;
//         this.villageImg = params.villageImg || "f4";
//         this.Consume = params.Consume || 50;
//         this.people = params.people;
//         this.traderNumCurrent = params.traderNumCurrent;
//         this.traderPacket = params.traderPacket;
//         this.traderSpeed = params.traderSpeed;
//         this.traderNum = params.traderNum;
//         this.civilAdded = params.civilAdded;

//         this.bManager.bList = params.bManager.bList || [];
//         this.bManager.village = this;

//         this.armyEventCount = params.armyEventCount;

//         this.eventList = params.eventList;
//         this._advEvents = null;

//         //占领的绿洲列表
//         this.oasisList = [];
//         for(let it of params.oasisList) {
//             let oi = new villageObj();
//             oi.zoneId = it.zoneId;
//             oi.faithful = it.faithful;
//             oi.typeId = it.typeId;
//             oi.user = this.user;
//             this.oasisList.push(oi);
//         }
//         this.subVillageList = params.subVillageList;
//         this.canTrainedBuilder = params.canTrainedBuilder;

//         this.soldiersOutNotArrivedList = params.soldiersOutNotArrivedList;
//         this.soldiersInNotArrivedList = params.soldiersInNotArrivedList;
//         this.soldiersOutList = params.soldiersOutList;
//         this.soldiersInList = params.soldiersInList;
//         this.initArmy(params.soldiersString, params.studyString);
//     };
//     /**
//      * 建筑升级事件列表
//      */
//     get advEvents() {
//         if(!this._advEvents) {
//             this._advEvents = this.convertEventList(EventType.advBuild, this.eventList);
//         }
//         return this._advEvents;
//     }
//     _advEvents = null;
//     /**
//      * 对事件集合中的每个事件，根据其类型进行格式转换
//      * @param {*} col 
//      * @returns 
//      */
//     convertEventList(eType, col) {
//         let list = [];
//         let bl = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
//         for (let eii of col) {
//             if(eii.eType != eType) {
//                 continue;
//             }

//             let ev = {};
//             switch (eii.eType) {
//                 case EventType.advBuild://建筑升级
//                     ev.eHandle = eii.eHandle;
//                     ev.eStart = eii.eTime;
//                     ev.eEnd = eii.eStartTime;
//                     ev.uid = parseInt(eii.eParam);
//                     if (ev.uid > 0 && ev.uid <= 40) {
//                         let bg = this.bManager.getBuildingByUid(ev.uid);
//                         bl[bg.uid - 1] += 1;
//                         ev.grade = bg.grade + bl[bg.uid - 1];
//                         ev.gid = bg.gid;
//                         ev.buildingName = this.bManager.buildingName(bg);
//                         if (bg.gid > 0) {//避免出现该点已砸平而仍然列出建筑升级事件
//                             list.push(ev);
//                         }
//                     }
//                     break;

//                 case EventType.destroy://拆除建筑
//                     ev.eHandle = eii.eHandle;
//                     ev.eStart = eii.eTime;
//                     ev.eEnd = eii.eStartTime;
//                     ev.uid = parseInt(eii.eParam);

//                     let bg = this.bManager.getBuildingByUid(ev.uid);
//                     ev.gid = bg.gid;
//                     ev.grade = bg.grade;
//                     ev.buildingName = this.bManager.buildingName(bg);

//                     if (bg.gid > 0) {//避免出现该点已砸平而仍然列出拆除事件
//                         list.push(ev);
//                     }

//                     break;

//                 case EventType.train://造兵
//                     let elist = eii.eParam.trim().split(',');
//                     ev.soldierType = parseInt(elist[0]);
//                     ev.soldierNum = parseInt(elist[1]);
//                     ev.moreRes = parseInt(elist[2]);
//                     ev.oneSecond = eii.eStartTime - eii.eTime;
//                     ev.endTime = eii.eStartTime;
//                     ev.totalEndTime = eii.eStartTime + ev.oneSecond * (ev.soldierNum - 1);
//                     ev.trainLocation = TrainLocation[ev.soldierType];
//                     ev.soldierName = sNameList[ev.soldierType][0];
//                     list.push(ev);
//                     break;

//                 case EventType.transArmy://军队调动
//                 default:
//                     list.push(eii);
//                     break;
//             }
//         } 
//         return list;
//     }
//     initArmy(soldiersString, studyString)
//     {
//         let am = new army(this);

//         am.zoneId = this.zoneId;
//         am.zoneName = this.villageName;
//         am.simZoneId = this.zoneId;
//         am.state = 0;
//         am.uid = this.uid;
//         am.startTime = ((Date.now()/1000)|0);
//         am.endTime = ((Date.now()/1000)|0);

//         if (this.typeId > 20) {
//             am.race = this.user.uInfo.race;
//         } else {
//             am.race = raceType.NATURE;
//         }
//         am.soldiersString = soldiersString;
//         am.studyString = studyString;

//         this.soldiers = am;
//     }
//     /**
//      * 取军队移动事件的统计结果（用于dorf1）
//      * @returns {[](armyEventCountInfo)} 军事行动统计信息数组 
//      */
//     getArmyEventCount() {
//         return this.armyEventCount;
//     }
// };

// /**
//  * 返回暴仓时间字符串
//  * @param {*} maxres 资源仓库大小
//  * @param {*} reseve 当前资源量
//  * @param {*} resoutput 资源产量
//  * @returns 
//  */
// function getResFullTime(maxres, reseve, resoutput) {
//     if (resoutput > 0) {
//         let s = Math.ceil((maxres-reseve) / (resoutput/3600));
//         let ret = Math.floor(1.0 * s / 3600) + ":" + Math.floor((1.0 * s % 3600) / 60).toString().padStart(2, "0") + ":" + Math.floor(1.0 * s % 60).toString().padStart(2, "0");
//         return ret;
//     } else if (resoutput < 0) {
//         let s = Math.ceil(reseve / (resoutput/3600));
//         s = Math.abs(s);
//         let ret = Math.floor(1.0 * s / 3600) + ":" + Math.floor((1.0 * s % 3600) / 60).toString().padStart(2, "0") + ":" + Math.floor(1.0 * s % 60).toString().padStart(2, "0");
//         return ret;
//     }
//     return "9999:99:99";
// }

// class bManager
// {
//     /**
//      * 根据建筑物的位置坐标查询并返回相应对象
//      * @param {*} rt 建筑物的位置坐标
//      * @returns {building} 对应的建筑物对象
//      */
//     getBuildingByUid(rt) {
//         if (rt < 1 || rt > 40)
//             return null;
//         else
//             return this.bList[rt - 1];
//     }

//     buildingName(bd) {
//         if (bd.gid <= 40 && bd.gid > 0) {
//             return buildingDescList[bd.gid][0];
//         } else {
//             return "未开放的建筑";
//         }
//     }

//   	/**
// 	 * 建筑描述属性，返回当前建筑对象的描述
// 	 */
// 	buildingDesc(bd) {
// 		if (bd.gid <= 40 && bd.gid > 0) {
// 			return buildingDescList[bd.gid][1];
// 		} else {
// 			return "未开放的建筑";
// 		}
// 	}

// 	/**
// 	 * 建筑物升级所需时间
// 	 */
// 	GradingTime(bd) {
// 		let retVal = bProperty[bd.gid][this.buildingNextGrade(bd)][8] / session.config.Speed;

//         let _effect = 1;
//         let bu = this.getBuildingByGid(buildingType.B15_MainBuilding);
//         if (bu.uid > 0) {
//             _effect = this.effect(bu) / 100;
//         }

//         return (retVal * _effect) | 0;
// 	}

//     /**
//      * 建筑物的效果，不同的建筑物有不同的含义，仓库为存储量，竞技场为速度加成。。。
//      * @param {*} bd 
//      * @returns 
//      */
//     effect(bd) {
//         return this.getEffect(bd, bd.grade);
//     }

//     /**
//      * 建筑物下一级的效果，不同的建筑物有不同的含义，仓库为存储量，竞技场为速度加成。。。
//      */
//     effectNextGrade(bd)
//     {
//         return this.getEffect(bd, this.buildingNextGrade(bd));
//     }

//     getEffect(bd, _grade) {
//         if (bd.grade < 0 || bd.grade > 20 || bd.gid < 0 || bd.gid > 40) {
//             return 0;
//         } else {
//             if (bd.gid == buildingType.B23_Cranny) {
//                 if (this.village != null && this.village.user != null) {
//                     if (this.village.user.uInfo.race == raceType.Gaul) {//高卢拥有两倍的山洞
//                         return (bProperty[bd.gid][_grade][7] * 2 * session.config.exchange);
//                     } else {
//                         return (bProperty[bd.gid][_grade][7] * session.config.exchange);
//                     }
//                 } else {
//                     return (bProperty[bd.gid][_grade][7] * session.config.exchange);
//                 }
//             } else if (bd.gid <= 4) {//资源
//                 return (bProperty[bd.gid][_grade][7] * session.config.exchange * session.config.Output);
//             } else {
//                 return bProperty[bd.gid][_grade][7];
//             }
//         }
//     }


//     /**
//      * 作为容器对象的村庄对象
//      */
//     village = null;

// 	/**
// 	 * 建筑下一级别属性字段，计算当前尚有几个未完成的针对该建筑物的升级事件，来得出该建筑物的下一个级别
// 	 */
//     buildingNextGrade(bd) {
// 		return Math.min(bd.grade + 1 + this.buildingCurBuildingNum(bd), this.MaxGrade(bd));
//     }

//     buildingCurBuildingNum(bd) {
//         let ret = 0;
//         for(let ev of this.village.advEvents) {
//             if ( ev.uid == bd.uid) {
//                 ret++;
//             }
//         }

//         return ret;
//     }

//     /**
//      * 所有在建建筑数量\在建资源田数量\在建内城建设数量
//      */
//     get BuildingEventNum()
//     {
//         if (this._BuildingEventNum == null)
//         {
//             this._BuildingEventTime = ((Date.now()/1000)|0);
//             this._BuildingEventNum = [0, 0, 0];
//             for(let ev of this.village.advEvents) {
//                 this._BuildingEventNum[0] += 1;

//                 if (parseInt(ev.uid) <= 18) {
//                     this._BuildingEventNum[1] += 1;
//                 } else {
//                     this._BuildingEventNum[2] += 1;
//                 }
//             };
//         }

//         return this._BuildingEventNum;
//     }
//     set BuildingEventNum(value) {
//         this._BuildingEventNum = value;
//     }

//     get BuildingEventNum_all()
//     {
//         return this.BuildingEventNum[BuildingEventType.ALL];
//     }
//     get BuildingEventNum_other()
//     {
//         return this.BuildingEventNum[BuildingEventType.OTHER];
//     }
//     get BuildingEventNum_res()
//     {
//         return this.BuildingEventNum[BuildingEventType.RES];
//     }

//     _canAdvBuildingEvent(_uid)
//     {
//         let en = 0, _enabled = 0;
//         let ub = this.village.user;
//         //首先根据种族、PLUS等条件，决定是否能继续造建筑
//         if (ub.uInfo.race == raceType.Rome) {
//             if (_uid <= 18) {
//                 en = this.BuildingEventNum_res;
//             } else {
//                 en = this.BuildingEventNum_other;
//             }
//             if (en >= 2 || this.BuildingEventNum_all >= 3) {
//                 _enabled = 1;//已经有建筑在建造
//             }
//         } else {
//             en = this.BuildingEventNum_all;
//             if (en >= 2) {
//                 _enabled = 1;
//             }
//         }
//         return _enabled;
//     }

//     canAdvBuildingEvent(_uid) {
//         let en = 0, _enabled = 0;
//         let ub = this.village.user;
//         //首先根据种族、PLUS等条件，决定是否能继续造建筑
//         if (ub.uInfo.race == raceType.Rome) {
//             if (_uid <= 18) {
//                 en = this.BuildingEventNum_res;
//             } else {
//                 en = this.BuildingEventNum_other;
//             }
//             if (en >= 2 || this.BuildingEventNum_all >= 3)
//                 _enabled = 1;//已经有建筑在建造
//         } else {
//             en = this.BuildingEventNum_all;
//             if (en >= 2)
//                 _enabled = 1;
//         }
//         return _enabled;
//     }

//     /**
//      * 构建可建造建筑列表
//      * @param {*} _uid  新建筑的UID
//      * @returns 返回可建造建筑列表，其中的对象类型为Desc_Building
//      */
//     EnabledBuildingList(_uid) {
//         let al = [];

//         let bd = this.getBuildingByUid(_uid);//获取对应的建筑物对象

//         if (!((bd.gid == 0) && (bd.grade == 0))) {//如果建筑物级别不为0，或者建筑物gid不为0，则不能建造
//             return al;
//         }

//         let _enabled = this.canAdvBuildingEvent(_uid);

//         for (let i = 5; i <= 40; i++) {
//             //生成建筑物描述对象db
//             let db = new Desc_Building();
//             db.uid = _uid;
//             db.gid = i;
//             db.enabled = _enabled;

//             if (this.checkTech(db) == false) {
//                 continue;
//             }

//             bd.gid = i;//先虚拟设置当前建筑物的Gid，调用结束前重新设置为0

//             if (db.enabled == 0) {
//                 //资源监测流程
//                 let nextGrade = this.buildingNextGrade(bd);
//                 if (
//                     this.village.res.wood_reserve < buildingReqRes(i, nextGrade, 1) ||
//                     this.village.res.mud_reserve < buildingReqRes(i, nextGrade, 2) ||
//                     this.village.res.iron_reserve < buildingReqRes(i, nextGrade, 3) ||
//                     this.village.res.food_reserve < buildingReqRes(i, nextGrade, 4)
//                     )
//                 {
//                     db.enabled = 2;//资源不足
//                 }
//                 //资源监测流程完成

//                 if (db.enabled == 0) {
//                     //判断粮耗，决定是否能继续建造建筑
//                     let addedConsume = buildingReqRes(i, nextGrade, 5);//建造该建筑的下一级的预增粮耗
//                     if (i != 4 && this.village.people + addedConsume >= this.village.res.food_output) {//如果村庄当前粮耗+预增粮耗>=村庄当前总粮产，则不允许建造
//                         db.enabled = 4;//粮食产量不足，你需要先升级农场
//                     }
//                 }
//             }

//             //	bProperty数组结构
//             //	等级	木头	黏土	铁矿	粮食	人口	文明	增长	MB 1
//             //	0	,	0	,	0	,	0	,	0	,	0	,	0	,	3 	,	0
//             db.gid = i;
//             db.bName = buildingDescList[i][0];
//             db.desc = buildingDescList[i][1];
//             db.wood = buildingReqRes(i, 1, 1);
//             db.mud = buildingReqRes(i, 1, 2);
//             db.iron = buildingReqRes(i, 1, 3);
//             db.food = buildingReqRes(i, 1, 4);
//             db.food_req = buildingReqRes(i, 1, 5);
//             db.dt = this.GradingTime(bd);
//             al.push(db);

//             bd.gid = 0;
//         }

//         return al;
//     }

//     /**
//      * 计算木、泥、铁、粮、仓库、谷仓、山洞、陷阱的最高级别
//      */
//     get maxGrade()
//     {
//         this._maxGrade = [0, 0, 0, 0, 0, 0, 0, 0];
//         for (let i = 0; i < this.village.bManager.bList.length; i++) {
//             let __gid = this.village.bManager.bList[i].gid;
//             let __grade = this.village.bManager.bList[i].grade;
//             switch (__gid) {
//                 case buildingType.B01_Wood:
//                     if (__grade > this._maxGrade[0])
//                         this._maxGrade[0] = __grade;
//                     break;

//                 case buildingType.B02_Mud:
//                     if (__grade > this._maxGrade[1])
//                         this._maxGrade[1] = __grade;
//                     break;

//                 case buildingType.B03_Iron:
//                     if (__grade > this._maxGrade[2])
//                         this._maxGrade[2] = __grade;
//                     break;

//                 case buildingType.B04_Food:
//                     if (__grade > this._maxGrade[3])
//                         this._maxGrade[3] = __grade;
//                     break;

//                 case buildingType.B10_Warehouse:
//                 case buildingType.B38_G_Warehouse:
//                     if (__grade > this._maxGrade[4])
//                         this._maxGrade[4] = __grade;
//                     break;

//                 case buildingType.B11_Granary:
//                 case buildingType.B39_G_Granary:
//                     if (__grade > this._maxGrade[5])
//                         this._maxGrade[5] = __grade;
//                     break;

//                 case buildingType.B23_Cranny:
//                     if (__grade > this._maxGrade[6])
//                         this._maxGrade[6] = __grade;
//                     break;

//                 case buildingType.B36_Trapper:
//                     if (__grade > this._maxGrade[7])
//                         this._maxGrade[7] = __grade;
//                     break;
//             }
//         }
//         return this._maxGrade;
//     }

//     /**
//      * 计算木、泥、铁、粮、仓库、谷仓、山洞的伪最低级别（当最低级别为20时，既有可能最低级别为20，也有可能根本就没有任何相关建筑）
//      */
//     get minGrade()
//     {
//         if (this._minGrade != null) {
//             return this._minGrade;
//         }

//         this._minGrade = [20, 20, 20, 20, 20, 20, 20];
//         for (let i = 0; i < this.village.bManager.bList.length; i++) {
//             let __gid = this.village.bManager.bList[i].gid;
//             let __grade = this.village.bManager.bList[i].grade;
//             switch (__gid) {
//                 case buildingType.B01_Wood:
//                     if (__grade < this._minGrade[0])
//                         this._minGrade[0] = __grade;
//                     break;

//                 case buildingType.B02_Mud:
//                     if (__grade < this._minGrade[1])
//                         this._minGrade[1] = __grade;
//                     break;

//                 case buildingType.B03_Iron:
//                     if (__grade < this._minGrade[2])
//                         this._minGrade[2] = __grade;
//                     break;

//                 case buildingType.B04_Food:
//                     if (__grade < this._minGrade[3])
//                         this._minGrade[3] = __grade;
//                     break;

//                 case buildingType.B10_Warehouse:
//                 case buildingType.B38_G_Warehouse:
//                     if (__grade < this._minGrade[4])
//                         this._minGrade[4] = __grade;
//                     break;

//                 case buildingType.B11_Granary:
//                 case buildingType.B39_G_Granary:
//                     if (__grade < this._minGrade[5])
//                         this._minGrade[5] = __grade;
//                     break;

//                 case buildingType.B23_Cranny:
//                     if (__grade < this._minGrade[6])
//                         this._minGrade[6] = __grade;
//                     break;
//             }
//         }
//         return this._minGrade;
//     }    

//     getMaxBuildingByGid(rt) {
//         let retValue = new building();

//         for (let i = 0; i < this.bList.length; i++) {
//             if (this.bList[i].gid == rt) {
//                 if (this.bList[i].grade >= retValue.grade) {
//                     retValue = this.bList[i];
//                 }

//                 if (retValue.grade == retValue.MaxGrade) {
//                     break;
//                 }
//             }
//         }
//         return retValue;
//     }

//     /**
//      * 建筑科技树检测函数
//      * @param {*} db {uid: 建造的地点, gid: 建造建筑物的类型}
//      * @returns {boolean} 是否能建造，True能 False不能 
//      */
//     checkTech(db) {
//         let _uid = db.uid;
//         let i = db.gid;
//         let ub = this.village.user;
//         let maxValue = this.maxGrade;
//         let bd1, bd2, bd3;

//         //开始定点建筑监测流程

//         if ((_uid == 26 && i != buildingType.B15_MainBuilding) || (_uid != 26 && i == buildingType.B15_MainBuilding))//26只能造中心大楼,非26不能造中心大楼
//             return false;

//         if ((_uid == 39 && i != buildingType.B16_RallyPoint) || (_uid != 39 && i == buildingType.B16_RallyPoint))//39只能造集结点,非39不能造集结点
//             return false;

//         if (
//             (_uid == 40 && i != buildingType.B31_H_Wall && i != buildingType.B33_M_Wall && i != buildingType.B32_X_Wall)
//             || (_uid != 40 && (i == buildingType.B31_H_Wall || i == buildingType.B33_M_Wall || i == buildingType.B32_X_Wall))
//             )//40只能造城墙,非40不能造城墙
//             return false;

//         if (_uid == 40) {
//             if (ub.uInfo.race == raceType.Rome && i != buildingType.B31_H_Wall)//只能罗马造城墙
//                 return false;
//             if (ub.uInfo.race == raceType.Teuton && i != buildingType.B32_X_Wall)//只能造日族城墙
//                 return false;
//             if (ub.uInfo.race == raceType.Gaul && i != buildingType.B33_M_Wall)//只能造高卢城墙
//                 return false;
//         }

//         //定点建筑监测完成

//         //开始科技树监测流程
//         if (i == buildingType.B37_HeroMasion) {
//             //英雄别院，要求中心大楼3级，集结点1级
//             if (this.getBuildingByGid(buildingType.B37_HeroMasion).uid != -1) {
//                 return false;
//             }

//             bd1 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             bd2 = this.getBuildingByGid(buildingType.B16_RallyPoint);
//             if (bd1.grade > 0 && bd2.grade > 0)
//             {
//                 if (bd1.grade < 3)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 if (bd2.grade < 1)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd2);
//                     return true;
//                 }
//             }
//             else {
//                 return false;
//             }
//         } else if (i == buildingType.B09_Bakery) {
//             //面包房，要求农场最大级别10，磨坊5，中心大楼5
//             if (this.getBuildingByGid(buildingType.B09_Bakery).uid != -1) {
//                 return false;
//             }

//             bd1 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             bd2 = this.getBuildingByGid(buildingType.B08_GrainMill);
//             if (bd1.grade > 0 && bd2.grade > 0) {
//                 if (bd1.grade < 5) {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }

//                 if (bd2.grade < 5) {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd2);
//                     return true;
//                 }
//             } else {
//                 return false;
//             }

//             if (maxValue[3] < 10){
//                 db.enabled = 3;
//                 let bd = this.getMaxBuildingByGid(buildingType.B04_Food);
//                 db.enabledDesc = "需要提升以下资源田级别到10级:" + this.buildingName(bd) + "(当前" + bd.grade + "级)";
//                 return true;
//             }
//         } else if (i == buildingType.B06_Brickyard) {
//             //砖块场，要求粘土矿最大级别10，中心大楼5
//             if (this.getBuildingByGid(buildingType.B06_Brickyard).uid != -1)
//                 return false;

//             bd1 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (bd1.grade < 5)
//             {
//                 if (bd1.grade > 0)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 else
//                     return false;
//             }

//             if (maxValue[1] < 10)
//             {
//                 db.enabled = 3;
//                 let bd = this.getMaxBuildingByGid(buildingType.B02_Mud);
//                 db.enabledDesc = "需要提升以下资源田级别到10级:" + this.buildingName(bd) + "(当前" + bd.grade + "级)";
//                 return true;
//             }
//         } else if (i == buildingType.B08_GrainMill) {
//             //磨坊，要求农场最大级别5
//             if (this.getBuildingByGid(buildingType.B08_GrainMill).uid != -1) {
//                 return false;
//             }

//             if (maxValue[3] < 5)
//             {
//                 db.enabled = 3;
//                 let bd = this.getMaxBuildingByGid(buildingType.B04_Food);
//                 db.enabledDesc = "需要提升以下资源田级别到5级:" + this.buildingName(bd) + "(当前" + bd.grade + "级)";
//                 return true;
//             }
//         } else if (i == buildingType.B23_Cranny) {
//             //山洞
//             if (this.getBuildingByGid(buildingType.B23_Cranny).uid != -1 && maxValue[6] >= 0 && maxValue[6] < 10)//已经有山洞，但尚未到10级
//                 return false;
//         } else if (i == buildingType.B36_Trapper) {
//             //陷阱，要求高卢种族
//             if (ub.uInfo.race != raceType.Gaul)
//                 return false;

//             if (this.getBuildingByGid(buildingType.B36_Trapper).uid != -1 && maxValue[7] >= 0 && maxValue[7] < 20)//已经有陷阱，但尚未到20级
//                 return false;
//         } else if (i == buildingType.B11_Granary) {
//             //谷仓，要求中心大楼1
//             bd1 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (bd1.grade < 1)
//             {
//                 return false;
//             }

//             if (this.getBuildingByGid(buildingType.B11_Granary).uid != -1 && maxValue[5] >= 0 && maxValue[5] < 20)//已经有谷仓，但尚未到20级
//                 return false;
//         } else if (i == buildingType.B10_Warehouse) {
//             //仓库，要求中心大楼1
//             bd1 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (bd1.grade < 1)
//             {
//                 return false;
//             }

//             if (this.getBuildingByGid(buildingType.B10_Warehouse).uid != -1 && maxValue[4] >= 0 && maxValue[4] < 20)//已经有仓库，但尚未到20级
//                 return false;
//         } else if (i == buildingType.B07_Foundry) {
//             //铸造场，要求铁矿最大级别10，中心大楼5
//             if (this.getBuildingByGid(buildingType.B07_Foundry).uid != -1)
//                 return false;

//             bd1 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (bd1.grade < 5)
//             {
//                 if (bd1.grade > 0)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 else
//                     return false;
//             }

//             if (maxValue[2] < 10)
//             {
//                 db.enabled = 3;
//                 let bd = this.getMaxBuildingByGid(buildingType.B03_Iron);
//                 db.enabledDesc = "需要提升以下资源田级别到10级:" + this.buildingName(bd) + "(当前" + bd.grade + "级)";
//                 return true;
//             }
//         } else if (i == buildingType.B05_Sawmill) {
//             //木材场，要求木头矿最大级别10，中心大楼5
//             if (this.getBuildingByGid(buildingType.B05_Sawmill).uid != -1) {
//                 return false;
//             }

//             bd1 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (bd1.grade < 5) {
//                 if (bd1.grade > 0) {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 else
//                     return false;
//             }

//             if (maxValue[0] < 10) {
//                 db.enabled = 3;
//                 let bd = this.getMaxBuildingByGid(buildingType.B01_Wood);
//                 db.enabledDesc = "需要提升以下资源田级别到10级:" + this.buildingName(bd) + "(当前" + bd.grade + "级)";
//                 return true;
//             }
//         } else if (i == buildingType.B18_Embassy) {
//             //会馆，要求中心大楼1
//             if (this.getBuildingByGid(buildingType.B18_Embassy).uid != -1)
//                 return false;

//             bd1 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (bd1.grade < 1)
//             {
//                 return false;
//             }
//         } else if (i == buildingType.B17_Market) {
//             //市场，要求中心大楼3，仓库1，谷仓1
//             if (this.getBuildingByGid(buildingType.B17_Market).uid != -1)
//                 return false;

//             bd1 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (bd1.grade < 3)
//             {
//                 if (bd1.grade > 0)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 else
//                     return false;
//             }
//         } else if (i == buildingType.B28_TradeOffice) {
//             //交易所，要求市场20，马厩10
//             if (this.getBuildingByGid(buildingType.B28_TradeOffice).uid != -1)
//                 return false;

//             bd1 = this.getBuildingByGid(buildingType.B17_Market);
//             if (bd1.grade < 20)
//             {
//                 if (bd1.grade > 0)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 else
//                     return false;
//             }

//             bd2 = this.getBuildingByGid(buildingType.B20_Stable);
//             if (bd2.grade < 10)
//             {
//                 if (bd2.grade > 0)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd2);
//                     return true;
//                 }
//                 else
//                     return false;
//             }
//         } else if (i == buildingType.B25_Residence) {
//             //小宫殿，要求中心大楼5，没有大宫殿
//             if (this.getBuildingByGid(buildingType.B26_Palace).uid != -1 || this.getBuildingByGid(buildingType.B25_Residence).uid != -1) {
//                 return false;
//             }

//             bd1 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (bd1.grade < 5) {
//                 if (bd1.grade > 0) {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 } else {
//                     return false;
//                 }
//             }
//         } else if (i == buildingType.B26_Palace) {
//             //大宫殿，要求中心大楼5，会馆1，没有小宫殿，并且要求当前玩家所有村子中都没有大宫殿（包括在建中的）
//             if (this.getBuildingByGid(buildingType.B26_Palace).uid != -1 || this.getBuildingByGid(buildingType.B25_Residence).uid != -1) {
//                 return false;
//             }

//             for(let vo of this.village.user.villageObjList) {
//                 if (vo.bManager.getBuildingByGid(buildingType.B26_Palace).uid != -1) {
//                     return false;
//                 }
//             }

//             bd1 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (!!bd1 && bd1.grade > 0) {
//                 if (bd1.grade < 5) {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//             } else {
//                 return false;
//             }

//             bd2 = this.getBuildingByGid(buildingType.B18_Embassy);
//             if (!bd2 || bd2.grade < 1) {
//                 return false;
//             }
//         } else if (i == buildingType.B34_Stonemason) {
//             //石匠铺，要求中心大楼5，大宫殿等级3
//             if (this.getBuildingByGid(buildingType.B34_Stonemason).uid != -1) {
//                 return false;
//             }

//             bd1 = this.getBuildingByGid(buildingType.B26_Palace);
//             bd2 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (bd1.grade > 0 && bd2.grade > 0) {
//                 if (bd1.grade < 3) {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 if (bd2.grade < 5) {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd2);
//                     return true;
//                 }
//             }
//             else {
//                 return false;
//             }
//         } else if (i == buildingType.B24_TownHall) {
//             return false;
//         } else if (i == buildingType.B22_Academy) {
//             //研究所，要求兵营3，中心大楼3
//             if (this.getBuildingByGid(buildingType.B22_Academy).uid != -1)
//                 return false;

//             bd1 = this.getBuildingByGid(buildingType.B19_Barracks);
//             bd2 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (bd1.grade > 0 && bd2.grade > 0)
//             {
//                 if (bd1.grade < 3)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 if (bd2.grade < 3)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd2);
//                     return true;
//                 }
//             }
//             else
//                 return false;
//         } else if (i == buildingType.B13_Armoury) {
//             //军械库，要求研究所1
//             if (this.getBuildingByGid(buildingType.B13_Armoury).uid != -1)
//                 return false;

//             bd1 = this.getBuildingByGid(buildingType.B22_Academy);
//             if (bd1.grade < 1)
//             {
//                 return false;
//             }
//         } else if (i == buildingType.B19_Barracks) {
//             //兵营，要求中心大楼3，集结点1
//             if (this.getBuildingByGid(buildingType.B19_Barracks).uid != -1 || this.getBuildingByGid(buildingType.B16_RallyPoint).grade < 1)
//                 return false;

//             bd1 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (bd1.grade < 3)
//             {
//                 if (bd1.grade > 0)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 else
//                     return false;
//             }
//         } else if (i == buildingType.B12_Blacksmith) {
//             //铁匠铺，要求研究院3
//             if (this.getBuildingByGid(buildingType.B12_Blacksmith).uid != -1)
//                 return false;

//             bd1 = this.getBuildingByGid(buildingType.B22_Academy);
//             if (bd1.grade < 3)
//             {
//                 if (bd1.grade > 0)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 else
//                     return false;
//             }
//         } else if (i == buildingType.B20_Stable) {
//             //马厩，要求研究院5，铁匠铺3
//             if (this.getBuildingByGid(buildingType.B20_Stable).uid != -1)
//                 return false;

//             bd1 = this.getBuildingByGid(buildingType.B12_Blacksmith);
//             bd2 = this.getBuildingByGid(buildingType.B22_Academy);
//             if (bd1.grade > 0 && bd2.grade > 0)
//             {
//                 if (bd1.grade < 3)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 if (bd2.grade < 5)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd2);
//                     return true;
//                 }
//             }
//             else
//                 return false;
//         } else if (i == buildingType.B14_Arena) {
//             //竞技场，要求集结点15
//             if (this.getBuildingByGid(buildingType.B14_Arena).uid != -1)
//                 return false;

//             bd1 = this.getBuildingByGid(buildingType.B16_RallyPoint);
//             if (bd1.grade < 15)
//             {
//                 if (bd1.grade > 0)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 else
//                     return false;
//             }
//         } else if (i == buildingType.B21_Workshop) {
//             //工场，要求研究院10，中心大楼5
//             if (this.getBuildingByGid(buildingType.B21_Workshop).uid != -1)
//                 return false;

//             bd1 = this.getBuildingByGid(buildingType.B22_Academy);
//             bd2 = this.getBuildingByGid(buildingType.B15_MainBuilding);
//             if (bd1.grade > 0 && bd2.grade > 0)
//             {
//                 if (bd1.grade < 10)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 if (bd2.grade < 5)
//                 {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd2);
//                     return true;
//                 }
//             }
//             else
//                 return false;
//         } else if (i == buildingType.B31_H_Wall) {
//             //罗马城墙，要求罗马种族，并且先前没有造过城墙
//             if (this.getBuildingByGid(buildingType.B31_H_Wall).uid != -1 || ub.uInfo.race != raceType.Rome) {
//                 return false;
//             }
//         } else if (i == buildingType.B32_X_Wall) { //日族城墙，要求日族
//             if (this.getBuildingByGid(buildingType.B32_X_Wall).uid != -1 || ub.uInfo.race != raceType.Teuton)
//                 return false;
//         } else if (i == buildingType.B33_M_Wall) { //高卢城墙，要求高卢种族
//             if (this.getBuildingByGid(buildingType.B33_M_Wall).uid != -1 || ub.uInfo.race != raceType.Gaul)
//                 return false;
//         } else if (i == buildingType.B40_Wonder) {//世界奇迹
//             return false; //需要联盟成员具备3个10级以上的封印球才能启动
//         }
//         else if (i == buildingType.B35_Brewery) {//酒馆
//             return false;
//         } else if (i == buildingType.B27_Treasury) {//宝库
//             return false;
//         } else if (i == buildingType.B29_G_Barracks) { //大兵营
//             //大兵营，要求兵营20，非主村
//             if (this.getBuildingByGid(buildingType.B29_G_Barracks).uid != -1 || this.village.zoneId == this.village.user.curVillage) {
//                 return false;
//             }

//             bd1 = this.getBuildingByGid(buildingType.B19_Barracks);
//             if (bd1.grade < 20) {
//                 if (bd1.grade > 0) {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 } else {
//                     return false;
//                 }
//             }
//         } else if (i == buildingType.B30_G_Stable) { //大马厩
//             //大马厩，要求马厩20，非主村
//             if (this.getBuildingByGid(buildingType.B30_G_Stable).uid != -1 || this.village.zoneId == this.village.user.curVillage) {
//                 return false;
//             }

//             bd1 = this.getBuildingByGid(buildingType.B20_Stable);
//             if (bd1.grade < 20) {
//                 if (bd1.grade > 0) {
//                     db.enabled = 3;
//                     db.enabledDesc = "科技不足,需要提升以下建筑物级别:" + this.buildingName(bd1);
//                     return true;
//                 }
//                 else {
//                     return false;
//                 }
//             }
//         } else if (i == buildingType.B39_G_Granary) {//大谷仓
//             return false;
//         } else if (i == buildingType.B38_G_Warehouse) {//大仓库
//             return false;
//         } else {
//             if (this.getBuildingByGid(i).uid != -1)
//                 return false;
//         }

//         return true;
//         //科技树检测完成
//     }

//     /**
//      * 根据GID返回对应建筑物当前的数量(包括未建成)
//      * @param {*} rt 建筑物GID
//      * @returns 返回该建筑物当前总数量
//      */
//     getNumByGid(rt) {
//         let retVal = 0;
//         for (let i = 0; i < this.bList.length; i++) {
//             if (this.bList[i].gid == rt) {
//                 retVal += 1;
//             }
//         }
//         return retVal;
//     }

//     /**
//      * 根据建筑物的buildingType查询并返回相应对象
//      * 注意：要判断某个建筑物不存在（存在的建筑物，包括级别大于零，还有级别等于0但正在建造两种情况），只能根据返回对象的uid==-1来判断。
//      * @param {*} rt 建筑物类型 buildingType
//      * @returns 对应的建筑物对象
//      */
//     getBuildingByGid(rt) {
//         for (let i = 0; i < this.bList.length; i++) {
//             if (this.bList[i].gid == rt)
//                 return this.bList[i];
//         }
//         return  {
//             gid : 0,
//             grade: 0,
//             uid: -1,
//         };
//     }

// 	/***
// 	 * 建筑物所能修建的最高级别，增加了主村、分村判断
// 	 */
// 	MaxGrade(bd) {
// 		if ((this.village != null) && (this.village.user != null) && (this.village.zoneId != this.village.user.curVillage)) { //分村
// 			return Grade_Slave[bd.gid];
// 		} else {
// 			//主村，或者无法判断是否主村分村
// 			return Grade_Master[bd.gid];
// 		}
// 	}


//     /**
//      * 资源满足时间（秒），如果已经满足则返回0,如果不能满足返回负数
//      * @param {*} bd 
//      * @returns 
//      */
//     hasGradingTime(bd) {
//         let retHour = 0;

//         //所需资源数据
//         let ri = {};
//         ri.wood = buildingReqRes(bd.gid, this.buildingNextGrade(bd), 1);
//         ri.mud = buildingReqRes(bd.gid, this.buildingNextGrade(bd), 2);
//         ri.iron = buildingReqRes(bd.gid, this.buildingNextGrade(bd), 3);
//         ri.food = buildingReqRes(bd.gid, this.buildingNextGrade(bd), 4);

//         if (
//             this.village.res.wood_reserve >= ri.wood &&
//             this.village.res.mud_reserve >= ri.mud &&
//             this.village.res.iron_reserve >= ri.iron &&
//             this.village.res.food_reserve >= ri.food)
//         { //已经满足
//             return 0;
//         }

//         if (
//             (this.village.res.wood_reserve < ri.wood && this.village.res.wood_output <= 0) ||
//             (this.village.res.mud_reserve < ri.mud && this.village.res.mud_output <= 0) ||
//             (this.village.res.iron_reserve < ri.iron && this.village.res.iron_output <= 0) ||
//             (this.village.res.food_reserve < ri.food && this.village.res.food_output <= 0))
//         {
//             //永远无法满足
//             return -1;
//         }

//         let th = (ri.wood - this.village.res.wood_reserve) / Math.max(this.village.res.wood_output, 1);
//         retHour = th;

//         th = (ri.mud - this.village.res.mud_reserve) / Math.max(this.village.res.mud_output, 1);
//         if (th > retHour) {
//             retHour = th;
//         }

//         th = (ri.iron - this.village.res.iron_reserve) / Math.max(this.village.res.iron_output, 1);
//         if (th > retHour) {
//             retHour = th;
//         }

//         th = (ri.food - this.village.res.food_reserve) / Math.max(this.village.res.food_output, 1);
//         if (th > retHour) {
//             retHour = th;
//         }

//         return (retHour * 3600)|0;
//     }

//     /**
//      * 获取资源充足时间提示字符串
//      * @param {*} bd 
//      * @returns 
//      */
//     GradingHint(bd) {
//         if (this.hasGradingTime(bd) < 0) {
//             return "<span>永远不能满足。</span>";
//         }

//         let tp = this.hasGradingTime(bd);
//         let now = (Date.now()/1000)|0;
//         let dt = now + tp;

//         let retVal = "";
//         if (tp < 3600*24) {
//             retVal = session.config.getHint(11, [TimeShow(dt)]);
//         } else {
//             retVal = session.config.getHint(12, [(tp/(3600*24))|0, TimeShow(dt)]);
//         }
//         return "<span>" + retVal + "</span>";
//     }

//     /**
//      * 预先判断是否能够建造 0可以升级 -4最高级 -5即将完成 -3粮产不足 -2资源不足 -6仓库不足 -7谷仓不足 -8要塞无法升级 -1建筑队列已满
//      * @returns 返回错误原因，正确返回0
//      */
//     preGrading(bd) {
//         if (bd.grade >= this.MaxGrade(bd)) {
//             return -4;//已经升级到了最高级
//         }

//         if (bd.grade + this.buildingCurBuildingNum(bd) >= this.MaxGrade(bd)) {
//             return -5;//即将完成建造
//         }

//         //判断种族，决定是否能继续造建筑
//         if (this.village.bManager._canAdvBuildingEvent(bd.uid) != 0) {
//             return -1;
//         }

//         //判断粮耗，决定是否能继续建造建筑
//         let addedConsume = buildingReqRes(bd.gid, this.buildingNextGrade(bd), 5);//建造该建筑的下一级的预增粮耗
//         if (bd.gid != 4 && this.village.people + addedConsume >= this.village.res.food_output) {
//             //如果村庄当前人口（非粮耗，也就是说不计军队）+预增粮耗>=村庄当前总粮产，则不允许建造
//             return -3;//粮食产量不足，你需要先升级农场
//         }

//         //然后查看村庄资源是否足够
//         if (
//             buildingReqRes(bd.gid, this.buildingNextGrade(bd), 1) > this.village.res.comm_max_reserve ||
//             buildingReqRes(bd.gid, this.buildingNextGrade(bd), 2) > this.village.res.comm_max_reserve ||
//             buildingReqRes(bd.gid, this.buildingNextGrade(bd), 3) > this.village.res.comm_max_reserve
//             )
//         {
//             return -6;//仓库容量不够
//         }

//         if (buildingReqRes(bd.gid, this.buildingNextGrade(bd), 4) > this.village.res.food_max_reserve) {
//             return -7;//谷仓容量不够
//         }

//         if (
//             this.village.res.wood_reserve >= buildingReqRes(bd.gid, this.buildingNextGrade(bd), 1) &&
//             this.village.res.mud_reserve >= buildingReqRes(bd.gid, this.buildingNextGrade(bd), 2) &&
//             this.village.res.iron_reserve >= buildingReqRes(bd.gid, this.buildingNextGrade(bd), 3) &&
//             this.village.res.food_reserve >= buildingReqRes(bd.gid, this.buildingNextGrade(bd), 4)
//             )
//         {
//             return 0;
//         } else {
//             return -2;//资源不足
//         }
//     }

//     bList = [];
// }

// /**
//  * 用于建筑物基本描述，当调用可建造建筑列表函数时，返回由多个Desc_Building构成的ArrayList
//  */
// class Desc_Building {
//     /**
//      * 构造函数，用于创建一个 Desc_Building 对象。
//      */
//     constructor() {
//         /**
//          * 建筑物的 GID。
//          */
//         this.gid = 0;
//         /**
//          * 建筑物建造地点 ID。
//          */
//         this.uid = -1;
//         /**
//          * 建筑物的名称。
//          */
//         this.bName = "神秘建筑";
//         /**
//          * 建筑物的说明。
//          */
//         this.desc = "尚未开放";
//         /**
//          * 表示建造该建筑的前提条件。
//          */
//         this.enabledDesc = "";
//         /**
//          * 表示该建筑是否可造
//          * 0 表示可建造
//          * 1 表示已经有建筑在建造，
//          * 2 表示资源不足
//          * 3 表示科技不足
//          * 4 表示粮耗不足，需要先升级农场
//          * 5 表示非空地。
//          */
//         this.enabled = 3;
//         /**
//          * 建造该建筑所需的时间。
//          */
//         this.dt = 0;
//         /**
//          * 表示建造该建筑所需的各项资源的消耗情况。
//          */
//         this.food_req = 0;
//         /**
//          * 建造该建筑所需的粮食数量。
//          */
//         this.food = 0;
//         /**
//          * 建造该建筑所需的铁矿数量。
//          */
//         this.iron = 0;
//         /**
//          * 建造该建筑所需的泥巴数量。
//          */
//         this.mud = 0;
//         /**
//          * 建造该建筑所需的木头数量。
//          */
//         this.wood = 0;
//     }
// }

// /**
//  * 建筑物
//  */
// class building {
//     constructor() {
//         this.gid = 0;
//         this.uid = -1;
//         this.grade = 0;
//     }

// 	/**
// 	 * 建筑物描述字符串，读写属性，格式为“类别,级别”
// 	 */
// 	get buildingString()
// 	{
// 		return `${this.gid},${this.grade}`;
// 	}
// 	set buildingString(value) {
// 		let sInfo = value.split(',');
// 		this.gid = parseInt(sInfo[0]);
// 		this.grade = parseInt(sInfo[1]);
// 		this._Consume = -1;
// 	}

// 	/**
// 	 * 是否空置
// 	 */
// 	get isNull() {
// 		return ((this.gid == 0) && (this.grade == 0));
// 	}

//     /**
//      * 建筑名称属性，返回当前建筑对象的名称
//      */
//     get buildingName() {
//         if (this.gid <= 40 && this.gid > 0) {
//             return buildingDescList[this.gid][0];
//         } else {
//             return "未开放的建筑";
//         }
//     }
// }

// //#endregion

// //#region 战报管理

// /**
//  * 单个的报告对象
//  * 字段：标题title,序列号sn,内容content,详细参数rParam,提交时间startTime,报告所属用户username,发生地点zoneId,报告类型rType
//  * 使用方法：首先调用带参数sn的构造函数，调入报告内容，然后使用reportInfo属性字段返回解析后的报告信息。
//  */
// class report
// {
//     /**
//      * 请求用户ID，用来判断是否能查看战报防御内容
//      */
//     requestUserId;
//     /**
//      * 是否进入TOP战报
//      */
//     isTop;
//     /**
//      * 报告序列号
//      */
//     sn;
//     /**
//      * 报告标题
//      */
//     title;
//     /**
//      * 报告备注
//      */
//     content;
//     /**
//      * 报告附加参数
//      */
//     rParam;
//     /**
//      * 报告提交时间
//      */
//     startTime;
//     /**
//      * 报告发起者Id
//      */
//     srcUserId;
//     /**
//      * 报告出发村庄的用户名
//      */
//     srcUserName;
//     /**
//      * 报告目标用户的联盟Id
//      */
//     srcAllyId;
//     /**
//      * 报告目标用户的联盟名称
//      */
//     srcAllyName;
//     /**
//      * 报告接受方用户ID
//      */
//     dstUserId;
//     /**
//      * 报告目标村庄的用户名
//      */
//     dstUserName;
//     /**
//      * 报告出发村庄的联盟Id
//      */
//     dstAllyId;
//     /**
//      * 报告出发村庄的联盟名称
//      */
//     dstAllyName;
//     /**
//      * src 已读
//      */
//     srcRead;
//     /**
//      * dst 已读
//      */
//     dstRead;
//     /**
//      * 是否未读
//      */
//     isUnread;
//     /**
//      * 报告类型 ReportType
//      */
//     reportType;
//     /**
//      * 报告被动接收村庄ID
//      */
//     SimZoneId;
//     /**
//      * 报告目标村庄名称
//      */
//     SimZoneName;
//     /**
//      * 报告发起村庄ID
//      */
//     OriZoneId;
//     /**
//      * 报告出发村庄名称
//      */
//     OriZoneName;
//     /**
//      * 攻击总米数
//      */
//     n_Ack = 0;
//     /**
//      * 防御总米数
//      */
//     n_Def = 0;
//     /**
//      * 攻击总损失
//      */
//     n_lAck = 0;
//     /**
//      * 防御总损失
//      */
//     n_lDef = 0;
//     /**
//      * 抢劫物资总数
//      */
//     n_Good = 0;
//     /**
//      * 发布模式 全部发布 遮ID 遮兵力
//      */
//     publishStatus = 0;
//     /**
//      * 发布者
//      */
//     publisher = 0;
//     /**
//      * 指示攻击方能否看到战报
//      */
//     get canKnowDefense() {
//         if (this.isDefense) {
//             return true;
//         }

//         if (this.n_Ack > this.n_lAck && (this.reportType == ReportType.rp_Invest || this.n_Ack > (this.n_Def * 0.1) || this.dstUserId == 0)) {
//             //如果攻击方能够返回，并且总米数达到了对方的1/10(该条件用于控制游侠暗杀、破坏情况下是否能看到详细战报)，或者是一次侦查行动，则可以看到战报
//             return true;
//         }

//         if (this.n_Def <= 0) {
//             return true;
//         }

//         if (((this.n_lDef / this.n_Def)) > 0.4) {
//             return true;
//         }

//         return false;
//     }

//     /**
//      * 指示防御方能否看到战报
//      */
//     get canKnowAttack() {
//         if (this.reportType == ReportType.rp_Invest) {
//             if (this.n_lAck == 0) {
//                 return false;
//             } else {
//                 return true;
//             }
//         } else {
//             return true;
//         }
//     }

//     /**
//      * 我方是否为防御方（关系到报告的查看）bool
//      */
//     isDefense;
//     /**
//      * 我方是否为攻击方 bool
//      */
//     isAttack;
//     /**
//      * 报告详细信息描述属性，根据报告类型，生成相应结构，以统一object对象返回，外围调用函数根据报告类型进行强制类型转换
//      */
//     get reportInfo() {
//         let rp = {};
//         switch (this.reportType) {
//             case ReportType.rp_Attack:
//                 rp = new reportInfo_Attack(this);
//                 break;

//             case ReportType.rp_AttackedHelp:
//                 rp = new reportInfo_AttackedHelp(this);
//                 break;

//             case ReportType.rp_SendHelp:
//                 rp = new reportInfo_SendHelp(this);
//                 break;

//             case ReportType.rp_SendRes:
//                 rp = new reportInfo_SendRes(this);
//                 break;

//             case ReportType.rp_Invest:
//                 rp = new reportInfo_Invest(this);
//                 break;

//             default:
//                 break;
//         }
//         return rp;
//     }
// }

// /**
//  * 支援（支援到达对方）
//  */
// class reportInfo_SendHelp
// {
//     constructor(rp)
//     {
//         this.helpArmy = new army();
//         this.helpArmy.soldiersString = rp.rParam;
//     }
// }

// /**
//  * 支援被攻击
//  */
// class reportInfo_AttackedHelp
// {
//     /**
//      * 原始协防部队
//      */
//     helpArmy;
//     /**
//      * 损失的协防部队
//      */
//     lostHelpArmy;
//     constructor(rp)
//     {
//         let pList = rp.rParam.trim().split('|');

//         this.helpArmy = new army();
//         this.helpArmy.soldiersString = pList[0];

//         this.lostHelpArmy = new army();
//         this.lostHelpArmy.soldiersString = pList[1];
//     }
// }

// /**
//  * 交易（自己物资送达对方）
//  */
// class reportInfo_SendRes
// {
//     constructor(rp)
//     {
//         this.wood = 0; 
//         this.mud = 0; 
//         this.iron = 0; 
//         this.food = 0;

//         let pList = rp.rParam.trim().split(',');
//         if (pList.length == 4) {
//             this.wood = parseInt(pList[0]);
//             this.mud = parseInt(pList[1]);
//             this.iron = parseInt(pList[2]);
//             this.food = parseInt(pList[3]);
//         }
//     }
// }

// /**
//  * 侦查信息结构体
//  */
// class reportInfo_Invest
// {
//     /**
//      * 攻击方军队
//      */
//     attackArmy;
//     /**
//      * 损失的攻击方军队
//      */
//     lostAttackArmy;
//     /**
//      * 对方资源情况
//      */
//     wood;mud;iron;food;
//     /**
//      * 防守方军队
//      */
//     defenseArmy;
//     /**
//      * 损失的防守方军队
//      */
//     lostDefenseArmy;
//     /**
//      * 协防部队
//      */
//     helpArmy = [];
//     /**
//      * 损失的协防部队
//      */
//     lostHelpArmy = [];
//     /**
//      * 汇总的协防军队 totoalArmyInfo
//      */
//     totalHelpArmy;
//     /**
//      * 汇总的协防军队损失 totoalArmyInfo
//      */
//     totalLostHelpArmy;

//     /**
//      * 构造函数
//      * @param {report} rp
//      */
//     constructor(rp)
//     {
//         /* 侦查报告结构：攻击士兵串|攻击损失串@防御士兵串|防御损失串[@协防士兵|协防损失[*协防士兵|协防损失]] */
//         let pList = rp.rParam.trim().split('@');
//         if (pList.length >= 1)
//         {
//             //pList[0],攻击方信息，包括攻击部队、损失部队
//             let attackInfo = pList[0].split('|');
//             this.attackArmy = new army();
//             this.attackArmy.soldiersString = attackInfo[0];
//             this.lostAttackArmy = new army();
//             this.lostAttackArmy.soldiersString = attackInfo[1];
//         }
//         if (pList.length >= 2)
//         {
//             //pList[1],防守方信息，包括防守部队、损失部队
//             let defenseInfo = pList[1].split('|');
//             this.defenseArmy = new army();
//             this.lostDefenseArmy = new army();
//             this.defenseArmy.soldiersString = defenseInfo[0];
//             this.lostDefenseArmy.soldiersString = defenseInfo[1];
//         }
//         if (pList.length >= 3)
//         {
//             //pList[2],协防方信息，包括协防部队、损失部队
//             let helpInfo = pList[2].split('*');
//             for (let i = 0; i < helpInfo.length; i++)
//             {
//                 let detail = helpInfo[i].split('|');
//                 let tmpArmy = new army();
//                 tmpArmy.soldiersString = detail[0];
//                 this.helpArmy.push(tmpArmy);
//                 tmpArmy = new army();
//                 tmpArmy.soldiersString = detail[1];
//                 this.lostHelpArmy.push(tmpArmy);
//             }
//         }
//         this.totalHelpArmy = new totoalArmyInfo();
//         this.totalLostHelpArmy = new totoalArmyInfo();
//         for (let j = 0; j < this.helpArmy.length; j++)
//         {
//             if ((this.helpArmy[j]).hasSoldier())
//             {
//                 for (let i = 0; i < 10; i++)
//                 {
//                     this.totalHelpArmy.sList[(this.helpArmy[j]).soldiers[i].sType - 1].addSoldier((this.helpArmy[j]).soldiers[i].soldierString);
//                 }
//             }
//         }
//         for (let j = 0; j < this.lostHelpArmy.length; j++)
//         {
//             if ((this.lostHelpArmy[j]).hasSoldier())
//             {
//                 for (let i = 0; i < 10; i++)
//                 {
//                     this.totalLostHelpArmy.sList[(this.lostHelpArmy[j]).soldiers[i].sType - 1].addSoldier((this.lostHelpArmy[j]).soldiers[i].soldierString);
//                 }
//             }
//         }
//     }
// }

// /**
//  * 攻击对方
//  */
// class reportInfo_Attack
// {
//     /**
//      * 攻击方军队
//      */
//     attackArmy;
//     /**
//      * 损失的攻击方军队
//      */
//     lostAttackArmy;
//     /**
//      * 缴获物
//      */
//     wood; mud; iron; food;
//     src0; dst0;//城墙
//     src1; dst1;//投石车攻击目标1
//     src2; dst2;//投石车攻击目标2
//     /**
//      * 防守方军队
//      */
//     defenseArmy;
//     /**
//      * 损失的防守方军队
//      */
//     lostDefenseArmy;
//     /**
//      * 协防部队
//      */
//     helpArmy = [];
//     /**
//      * 损失的协防部队
//      */
//     lostHelpArmy = [];
//     /**
//      * 汇总的协防军队 totoalArmyInfo
//      */
//     totalHelpArmy;
//     /**
//      * 汇总的协防军队损失 totoalArmyInfo
//      */
//     totalLostHelpArmy;

//     /**
//      * 构造函数
//      * @param {*} report 
//      * @param {*} rp 
//      */
//     constructor(rp) {
//         /* 攻击报告结构：攻击士兵串|抢劫木,抢劫泥,抢劫铁,抢劫粮|攻击损失串|建筑1,建筑1级别;建筑1,最终级别;建筑2,建筑2级别;建筑2,最终级别;建筑3,建筑3级别;建筑3,最终级别@防御士兵串|防御损失串[@协防士兵|协防损失[*协防士兵|协防损失]] */
//         this.src0 = new building();
//         this.dst0 = new building();
//         this.src1 = new building();
//         this.dst1 = new building();
//         this.src2 = new building();
//         this.dst2 = new building();

//         let pList = rp.rParam.trim().split('@');
//         if (pList.length >= 1) {
//             //pList[0],攻击方信息，包括攻击部队、缴获物、损失部队、砸毁的建筑
//             let attackInfo = pList[0].split('|');

//             this.attackArmy = new army();
//             this.attackArmy.soldiersString = attackInfo[0];
//             this.wood = 0; this.mud = 0; this.iron = 0; this.food = 0;
            
//             let resList = attackInfo[1].trim().split(',');
//             if (resList.length == 4) {
//                 this.wood = parseInt(resList[0]);
//                 this.mud = parseInt(resList[1]);
//                 this.iron = parseInt(resList[2]);
//                 this.food = parseInt(resList[3]);
//             }

//             this.lostAttackArmy = new army();
//             this.lostAttackArmy.soldiersString = attackInfo[2];
            
//             if (attackInfo.length >= 4) {
//                 let buildingList = attackInfo[3].trim().split(';');
//                 if (buildingList.length == 6) {
//                     this.src0 = new building();
//                     this.dst0 = new building();
//                     this.src0.buildingString = buildingList[0];
//                     this.dst0.buildingString = buildingList[1];
//                     this.src1 = new building();
//                     this.dst1 = new building();
//                     this.src1.buildingString = buildingList[2];
//                     this.dst1.buildingString = buildingList[3];
//                     this.src2 = new building();
//                     this.dst2 = new building();
//                     this.src2.buildingString = buildingList[4];
//                     this.dst2.buildingString = buildingList[5];
//                 }
//             }
//         }
//         this.defenseArmy = new army();
//         this.lostDefenseArmy = new army();
//         if (pList.length >= 2) {
//             //pList[1],防守方信息，包括防守部队、损失部队
//             let defenseInfo = pList[1].split('|');
//             this.defenseArmy.soldiersString = defenseInfo[0];
//             this.lostDefenseArmy.soldiersString = defenseInfo[1];
//         }
//         if (pList.length >= 3) {
//             //pList[2],协防方信息，包括协防部队、损失部队
//             let helpInfo = pList[2].split('*');
//             for (let i = 0; i < helpInfo.length; i++) {
//                 let detail = helpInfo[i].split('|');
//                 let tmpArmy = new army();
//                 tmpArmy.soldiersString = detail[0];
//                 this.helpArmy.push(tmpArmy);
//                 tmpArmy = new army();
//                 tmpArmy.soldiersString = detail[1];
//                 this.lostHelpArmy.push(tmpArmy);
//             }
//         }

//         this.totalHelpArmy = new totoalArmyInfo();
//         this.totalLostHelpArmy = new totoalArmyInfo();
//         for (let j = 0; j < this.helpArmy.length; j++) {
//             if ((this.helpArmy[j]).hasSoldier()) {
//                 for (let i = 0; i < 10; i++) {
//                     this.totalHelpArmy.sList[(this.helpArmy[j]).soldiers[i].sType - 1].addSoldier((this.helpArmy[j]).soldiers[i].soldierString);
//                 }
//             }
//         }
//         for (let j = 0; j < this.lostHelpArmy.length; j++) {
//             if ((this.lostHelpArmy[j]).hasSoldier()) {
//                 for (let i = 0; i < 10; i++) {
//                     this.totalLostHelpArmy.sList[((this.lostHelpArmy[j]).soldiers[i].sType) - 1].addSoldier((this.lostHelpArmy[j]).soldiers[i].soldierString);
//                 }
//             }
//         }
//     }
// }

// //#endregion

// //#region 军事相关

// /**
//  * 军队移动事件的统计结果
//  */
// class armyEventCountInfo
// {
//     /**
//      * 11我打别人 12派出增援 13返回增援 14打绿洲 15支援绿洲 99别人打我
//      */
//     eType;
//     /**
//      * 事件的数量
//      */
//     eNum;
//     /**
//      * 最早一个事件开始的时间
//      */
//     eStartTime;

//     constructor(et)
//     {
//         this.eType = et;
//         this.eStartTime = ((Date.now()/1000)|0) + 365*3600*24;
//         this.eNum = 0;
//     }
// }

// /**
//  * 汇总的军队信息
//  */
// class totoalArmyInfo
// {
// 	constructor()
// 	{
//         this.heroNumArry = [0,0,0,0,0];
//         this.hasSoldier = [false,false,false,false];
//         this.sList = new Array(40);
// 		for(let i=0; i<40; i++) {
// 			this.sList[i] = new soldier();
// 			this.sList[i].soldierString = `${i+1},0`;
// 		}
// 	}
// }

// class soldierInfo
// {
//     /**
//      * 士兵类型 SoldierType
//      */
//     st;
//     /**
//      * 士兵名称
//      */
//     sName;
//     /**
//      * 士兵数量
//      */
//     sNum;
// }

// /**
//  * 攻击事件参数对象，需要二次反馈以补充细节，如带投石车攻击时须指定攻击目标
//  */
// class armyInfo
// {
//     /**
//      * 可调动的军队列表，列表中每个对象是一个soldierInfo对象 soldierInfo[]
//      */
//     sList;
//     /**
//      * 0攻击、1抢劫、2侦查、3投石单砸、4投石双砸、5建立新村庄、6攻击绿洲（无人或有人）、7抢劫绿洲（无人或有人）、8游侠侦查、9游侠暗杀、10游侠破坏、11商人速建
//      */
//     mode;
//     /**
//      * 攻击目标村落ID
//      */
//     zoneId;
//     /**
//      * 攻击目标村落名称
//      */
//     zoneName;
//     /**
//      * 投石模式下，攻击目标1的GID
//      */
//     sim1;
//     /**
//      * 投石模式下，攻击目标2的GID
//      */
//     sim2;
//     /**
//      * 侦查模式下，侦查目标，0资源 1防御
//      */
//     invest;
//     /**
//      * 补充说明
//      */
//     note;
//     /**
//      * 空构造函数，仅仅完成初始化工作
//      */
//     constructor()
//     {
//         this.sList = [];
//         for (let i = 0; i < 11; i++)
//         {
//             this.sList[i] = new soldierInfo();
//         }
//         this.mode = 1;
//         this.zoneId = 0;
//         this.sim1 = 0;
//         this.sim2 = 0;
//         this.invest = 0;
//         this.note = "";
//     }
// }

// /**
//  * 对单个士兵进行描述的类
//  */
// class soldier
// {
//     /**
//      * 构造函数
//      * @param {army} _parent 所属军队对象
//      */
//     constructor(_parent)
//     {
//         /**
//          * 所属军队对象
//          */
//         this.parentArmy = _parent;
//         /**
//          * 研发是否完成属性，True完成，False未完成
//          */
//         this.study = false;
//         /**
//          * 士兵类型
//          */
//         this.sType = 0;
//         /**
//          * 士兵数量
//          */
//         this.sNum = 0;
//         /**
//          * 攻击级别
//          */
//         this.aGrade = 0;
//         /**
//          * 防御级别
//          */
//         this.dGrade = 0;
//     }

//     get info() {
//         return `(现有: ${this.sNum}, 攻击: ${this.aGrade}级, 防御: ${this.dGrade}级)`;
//     }

//     /**
//      * 兵种研发数据表
//      */
//     static sStudy = [
//         //	兵种	木头	黏土	铁矿	粮食	需时				其它条件
//         [	0	,	0	,	0	,	0	,	0	,	0		]	,	//	空
//         [	1	,	0	,	0	,	0	,	0	,	0		]	,	//	古罗马，无研发条件
//         [	2	,	700	,	620	,	1460,	580	,	8400	]	,	//	禁卫，军械库1，研1
//         [	3	,	1000,	740	,	1880,	640	,	9000	]	,	//	帝国兵，铁匠铺1，研5
//         [	4	,	940	,	740	,	360	,	400	,	6900	]	,	//	使节骑士，马厩1，研5
//         [	5	,	3400,	1860,	2760,	760	,	11700	]	,	//	帝国骑士，马厩5,研5
//         [	6	,	3400,	2660,	6600,	1240,	15000	]	,	//	将军骑士马厩10，研5
//         [	7	,	5500,	1540,	4200,	580	,	15600	]	,	//	冲撞车，工场1，研10
//         [	8	,	5800,	5500,	5000,	700	,	28800	]	,	//	火焰投石车，工场10，研15
//         [	9	,	15880,	13800,	36400,	22660,	24475	]	,	//	忽悠，集结点10，研20
//         [	10	,	0	,	0	,	0	,	0	,	0		]	,	//	拓荒，无研发条件
//         [	11	,	0	,	0	,	0	,	0	,	0		]	,	//	
//         [	12	,	940	,	700	,	1680,	520	,	7200	]	,	//	铁匠铺1，研1
//         [	13	,	1120,	700	,	360	,	400	,	6900	]	,	//	马厩1，研5
//         [	14	,	2200,	1900,	2040,	520	,	11100	]	,	//	马厩3，研5
//         [	15	,	2260,	1420,	2440,	880	,	11400	]	,	//	马厩5，研5
//         [	16	,	3100,	2580,	5600,	1180,	13500	]	,	//	马厩10，研15
//         [	17	,	5800,	2320,	2840,	610	,	16800	]	,	//	工场1，研10
//         [	18	,	5680,	5900,	5240,	700	,	28800	]	,	//	工场10，研15
//         [	19	,	15880,	22900,	25200,	22660,	24475	]	,	//	集结点10，研20
//         [	20	,	0	,	0	,	0	,	0	,	0		]	,	//	
//         [	21	,	0	,	0	,	0	,	0	,	0		]	,	//	
//         [	22	,	970	,	380	,	880	,	400	,	6000	]	,	//	研1
//         [	23	,	880	,	580	,	1560,	580	,	6300	]	,	//	铁匠铺1，研3
//         [	24	,	1060,	500	,	600	,	460	,	6000	]	,	//	中心大楼5，研1
//         [	25	,	2320,	1180,	2520,	610	,	10800	]	,	//	马厩3，研5
//         [	26	,	2800,	2160,	4040,	640	,	12900	]	,	//	马厩10，研15
//         [	27	,	6100,	1300,	3000,	580	,	14400	]	,	//	工场1，研10
//         [	28	,	5500,	4900,	5000,	520	,	28800	]	,	//	工场10，研15
//         [	29	,	18250,	13500,	20400,	16480,	19425	]	,	//	集结点5，研20
//         [	30	,	0	,	0	,	0	,	0	,	0		]			
//     ];

//     /**
//      * 士兵名称
//      */
//     get soldierName()
//     {
//         return sNameList[this.sType][0];
//     }

//     /**
//      * 士兵建造场所 0兵营 1马厩 2小宫殿或大宫殿 3工场
//      */
//     get trainLocation()
//     {
//         return TrainLocation[this.sType];
//     }

//     /**
//      * 当前资源可训练最大数量
//      */
//     get trainMaxNum() {
//         let retVal = this.parentArmy.village.res.food_reserve / this.train_food;
//         let temp = this.parentArmy.village.res.wood_reserve / this.train_wood;
//         if (temp < retVal)
//             retVal = temp;
//         temp = this.parentArmy.village.res.mud_reserve / this.train_mud;
//         if (temp < retVal)
//             retVal = temp;
//         temp = this.parentArmy.village.res.iron_reserve / this.train_iron;
//         if (temp < retVal)
//             retVal = temp;

//         return retVal|0;
//     }

//     get trainMaxNum_G()
//     {
//         let retVal = this.parentArmy.village.res.food_reserve / (this.train_food*3);
//         let temp = this.parentArmy.village.res.wood_reserve / (this.train_wood*3);
//         if (temp < retVal)
//             retVal = temp;
//         temp = this.parentArmy.village.res.mud_reserve / (this.train_mud*3);
//         if (temp < retVal)
//             retVal = temp;
//         temp = this.parentArmy.village.res.iron_reserve / (this.train_iron*3);
//         if (temp < retVal)
//             retVal = temp;

//         return retVal|0;
//     }

//     /**
//      * 当前攻防升级所需木头
//      * @param {*} stype 
//      * @returns 
//      */
//     curGradingWood(stype) {
//         if (stype == 0) {
//             return (sAdvanced[this.sType][this.aGrade][1] * session.config.exchange);
//         } else {
//             return (sAdvanced[this.sType][this.dGrade][1] * session.config.exchange);
//         }
//     }

//     /**
//      * 当前攻防升级所需泥巴
//      * @param {*} stype 
//      * @returns 
//      */
//     curGradingMud(stype) {
//         if (stype == 0) {
//             return (sAdvanced[this.sType][this.aGrade][2] * session.config.exchange);
//         } else {
//             return (sAdvanced[this.sType][this.dGrade][2] * session.config.exchange);
//         }
//     }

//     /**
//      * 当前攻防升级所需铁矿
//      * @param {*} stype 
//      * @returns 
//      */
//     curGradingIron(stype) {
//         if (stype == 0) {
//             return (sAdvanced[this.sType][this.aGrade][3] * session.config.exchange);
//         } else {
//             return (sAdvanced[this.sType][this.dGrade][3] * session.config.exchange);
//         }
//     }

//     /**
//      * 当前攻防升级所需食物
//      * @param {*} stype 
//      * @returns 
//      */
//     curGradingFood(stype) {
//         if (stype == 0) {
//             return (sAdvanced[this.sType][this.aGrade][4] * session.config.exchange);
//         } else {
//             return (sAdvanced[this.sType][this.dGrade][4] * session.config.exchange);
//         }
//     }

//     /**
//      * 当前升级攻所需时间
//      */
//     get curAGradingTime()
//     {
//         let mbGrade = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B12_Blacksmith).grade;
//         return (sAdvanced[this.sType][this.aGrade][Math.min(5 + mbGrade, 24)] / session.config.Speed) | 0;
//     }

//     /**
//      * 当前升级防所需时间
//      */
//     get curDGradingTime()
//     {
//         let mbGrade = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B13_Armoury).grade;
//         return (sAdvanced[this.sType][this.dGrade][Math.min(5 + mbGrade, 24)] / session.config.Speed) | 0;
//     }

//     addSoldier(sString)
//     {
//         let sParam = sString.split(',');
//         if (parseInt(sParam[0]) == this.sType)
//             this.sNum = this.sNum + parseInt(sParam[1]);
//     }

//     /**
//      * 士兵字符串属性，通过读写该字段获取士兵信息
//      */
//     get soldierString()
//     {
//         return (this.sType).toString() + "," + this.sNum.toString() + "," + this.aGrade.toString() + "," + this.dGrade.toString();
//     }
//     set soldierString(value) {
//         let sInfo = value.trim().split(',');
//         if (sInfo.length >= 2)
//         {
//             this.sType = parseInt(sInfo[0]);
//             this.sNum = Math.max(parseInt(sInfo[1]), 0);
//         }

//         if (sInfo.length > 2)
//             this.aGrade = Math.max(parseInt(sInfo[2]), 0);
//         else
//             this.aGrade = 0;

//         if (sInfo.length > 3)
//             this.dGrade = Math.max(parseInt(sInfo[3]), 0);
//         else
//             this.dGrade = 0;
//     }
//     /**
//      * 基础步攻
//      */
//     get fAttack()
//     {
//         //考虑金币加成的作用
//         return sProperty[this.sType][0];
//     }
//     /**
//      * 基础骑攻
//      */
//     get hAttack()
//     {
//         return sProperty[this.sType][1];
//     }
//     /**
//      * 基础步防
//      */
//     get fDefense()
//     {
//         return sProperty[this.sType][2];
//     }
//     /**
//      * 基础骑防
//      */
//     get hDefense()
//     {
//         return sProperty[this.sType][3];
//     }
//     /**
//      * 基础粮耗，不考虑绿洲怪物
//      */
//     get food()
//     {
//         if (this.sType > 30) {
//             return 0;//绿洲的怪不耗粮
//         } else
//         {
//             return sProperty[this.sType][4];
//         }
//     }
//     /**
//      * 基础粮耗，考虑绿洲怪物
//      */
//     get foodWithBeast()
//     {
//         return sProperty[this.sType][4];
//     }
//     /**
//      * 加成速度
//      */
//     get speed()
//     {
//         let retVal = 3;
//         let tEffect = 1;
//         if (this.sType == 0)
//         {
//             retVal = 19;
//         } else if (this.sType > 0 && this.sType <= 40)
//         {
//             retVal = sProperty[this.sType][5];
//         }

//         if (this.parentArmy != null && this.parentArmy.village != null) {
//             //考虑竞技场的作用
//             let bd = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B14_Arena);
//             if (bd.grade > 0)
//             {
//                 tEffect = bd.effect / 100.0;//竞技场的效果为：N级effect=100+N*10，20级effect=300
//             }
//             //考虑敏捷的影响
//             tEffect = this.parentArmy.village.user.effectMgr.CalcFinallyValue(em_Effect_Comm.speed, tEffect);
//         }
//         return (retVal * tEffect)|0;
//     }
//     /**
//      * 基础速度
//      */
//     get speed_basic()
//     {
//         let retVal = 3;
//         if (this.sType == 0) {
//             retVal = 19;
//         } else if (this.sType > 0 && this.sType <= 40)
//         {
//             retVal = sProperty[this.sType][5];
//         }

//         return retVal;
//     }
//     /**
//      * 基础装载量
//      */
//     get package()
//     {
//         return (sProperty[this.sType][6] * session.config.exchange);
//     }
//     /**
//      * 研发该兵种所需要的木头
//      */
//     get study_wood()
//     {
//         return (soldier.sStudy[this.sType][1] * session.config.exchange);
//     }
//     /**
//      * 研发该兵种所需要的泥巴
//      */
//     get study_mud()
//     {
//         return (soldier.sStudy[this.sType][2] * session.config.exchange);
//     }

//     /**
//      * 研发该兵种所需要的铁矿
//      */
//     get study_iron()
//     {
//         return (soldier.sStudy[this.sType][3] * session.config.exchange);
//     }
//     /**
//      * 研发该兵种所需要的食物
//      */
//     get study_food()
//     {
//         return (soldier.sStudy[this.sType][4] * session.config.exchange);
//     }
//     /**
//      * 研发该兵种所需要的时间（整数表示的秒）
//      */
//     get study_time()
//     {
//         return (soldier.sStudy[this.sType][5] / session.config.Speed) | 0;
//     }
//     /**
//      * 训练一个士兵所需木头
//      */
//     get train_wood()
//     {
//         return (sProperty[this.sType][8] * session.config.exchange);
//     }
//     /**
//      * 训练一个士兵所需泥巴
//      */
//     get train_mud()
//     {
//         return (sProperty[this.sType][9] * session.config.exchange);
//     }
//     /**
//      * 训练一个士兵所需铁矿
//      */
//     get train_iron()
//     {
//         return (sProperty[this.sType][10] * session.config.exchange);
//     }
//     /**
//      * 训练一个士兵所需粮食
//      */
//     get train_food()
//     {
//         return (sProperty[this.sType][11] * session.config.exchange);
//     }
//     /**
//      * 训练一个士兵所需时间
//      */
//     get train_time()
//     {
//         let mbGrade = 0;//建造场所的级别
//         if (this.sType < 31 && this.parentArmy != null && this.parentArmy.village != null)
//         {
//             switch (TrainLocation[this.sType])
//             {
//                 case 0:
//                     mbGrade = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B19_Barracks).grade;
//                     break;
//                 case 1:
//                     mbGrade = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B20_Stable).grade;
//                     break;
//                 case 2:
//                     mbGrade = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B26_Palace).grade;
//                     if (mbGrade <= 0)
//                     {
//                         mbGrade = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B25_Residence).grade;
//                     }
//                     break;
//                 case 3:
//                     mbGrade = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B21_Workshop).grade;
//                     break;
//             }
//             mbGrade = mbGrade > 0 ? mbGrade : 0;

//             return ((sProperty[this.sType][7] * Math.pow(0.964, mbGrade)) / session.config.Speed)|0;
//         }
//         else
//         {
//             return (sProperty[this.sType][7] / session.config.Speed)|0;
//         }
//     }

//     get train_time_max()
//     {
//         let mbGrade = 0;//建造场所的级别
//         if (this.sType < 31 && this.parentArmy != null && this.parentArmy.village != null)
//         {
//             switch (TrainLocation[this.sType])
//             {
//                 case 0:
//                     mbGrade = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B29_G_Barracks).grade;
//                     break;
//                 case 1:
//                     mbGrade = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B30_G_Stable).grade;
//                     break;
//                 case 2:
//                     mbGrade = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B26_Palace).grade;
//                     if (mbGrade <= 0)
//                     {
//                         mbGrade = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B25_Residence).grade;
//                     }
//                     break;
//                 case 3:
//                     mbGrade = this.parentArmy.village.bManager.getBuildingByGid(buildingType.B21_Workshop).grade;
//                     break;
//             }
//             mbGrade = mbGrade > 0 ? mbGrade : 0;

//             return ((sProperty[this.sType][7] * Math.pow(0.964, mbGrade)) / session.config.Speed)|0;
//         }
//         else
//         {
//             return (sProperty[this.sType][7] / session.config.Speed)|0;
//         }
//     }
// }

// /**
//  * 对一个村庄所有军队进行描述的类，本村军队为单一对象，协防军队和驻外军队为对象队列
//  */
// class army
// {
//     /**
//      * 构造函数，带所属村庄参数
//      * @param {villageObj} village 
//      */
//     constructor(village)
//     {
//         this.village = village;

//         /**
//          * 生产军队的原始村庄ID
//          */
//         if(village) {
//             this.zoneId = village.zoneId;
//         } else {
//             this.zoneId = 0;
//         }
//         this.soldiers = new Array(); //士兵列表
//         for (let i = 0; i < 10; i++) {
//             this.soldiers[i] = new soldier(this);
//         }

//         this.state = 0;

//         /**
//          * 军队所属用户ID
//          */
//         this.uid = 0;
//         /**
//          * 军队所属用户种族
//          */
//         this.race = 0;
//         /**
//          * 军队ID，取自armyList表，缺省为零
//          */
//         this.armyId = 0;
//         /**
//          * 军队出发时间
//          */
//         this.startTime = ((Date.now()/1000)|0);
//         /**
//          * 军队到达时间
//          */
//         this.endTime = ((Date.now()/1000)|0);
//         /**
//          * 目标村庄，对于本村驻外军队，simZoneId代表驻扎的地点；军队所属村庄（出产地）可以取自 zoneId 或 village 属性
//          */
//         this.simZoneId = 0;
//         /**
//          * 军队状态：
//          * 0 驻守模式：0状态不代表驻守本村，只有 srcZoneId == dstZoneId 才代表驻守本村，否则代表支援外村。当支援被派回时，新生成一支军队，状态为3，如果为全部派回，则删除原军队
//          * 1 攻击途中：当攻击发生后，该军队如果仍然存活，则转为状态3，但当忽悠村庄成功时会转为状态0
//          * 2 支援途中：当支援到达后，或者状态转为0，或者和已有的同村军队合并
//          * 3 返回途中：当返回后，队伍叠加到本村部队上，原军队删除
//          */
//         this.state;
//         /**
//          * 关联事件相关参数，事件句柄
//          */
//         this.eHandle = 0;
//         /**
//          * 关联事件相关参数，事件类型
//          */
//         this.eType = 0;
//         /**
//          * 关联事件相关参数，事件附加参数
//          */
//         this.eParam = "";
//         /**
//          * 关联事件相关参数，攻击模式
//          */
//         this.eAttackMode = 0;
//     }

//     /**
//      * 导入属性对象携带的信息
//      */
//     importInfo(data) {
//         this.armyId = data.armyId;
//         this.eAttackMode = data.eAttackMode;
//         this.endTime = data.endTime;
//         this.eParam = data.eParam;
//         this.eType = data.eType;
//         this.race = data.race;
//         this.soldiersString = data.soldiersString;
//         this.state = data.state;
//         this.uid = data.uid;
//         this.eHandle = data.eHandle;

//         this.zoneId = data.zoneId;
//         this.zoneName = data.zoneName;
//         this.village = session.getVillageByZid(this.zoneId);

//         this.simZoneId = data.simZoneId;
//         this.simZoneName = data.simZoneName;

//         return this;
//     }

//     /**
//      * 0攻击、1抢劫、2侦查、3投石单砸、4投石双砸、5建立新村庄、6攻击绿洲（无人或有人）、7抢劫绿洲（无人或有人）、8游侠侦查、9游侠暗杀、10游侠破坏、11商人速建
//      */
//     static attackMode = {
//         /**
//          * 0 攻击
//          */
//         attack: 0,
//         /**
//          * 1 抢劫
//          */
//         take: 1,
//         /**
//          * 2 侦查
//          */
//         invest: 2,
//         /**
//          * 3 单砸
//          */
//         singleDestroy: 3,
//         /**
//          * 4 双砸
//          */
//         doubleDestroy: 4,
//         /**
//          * 5 建立新村
//          */
//         newVillage: 5,
//         /**
//          * 6 攻击绿洲
//          */
//         attackOasis: 6,
//         /**
//          * 7 抢劫绿洲
//          */
//         takeOasis: 7,
//         /**
//          * 8 游侠侦查
//          */
//         heroInvest: 8,
//         /**
//          * 9 游侠暗杀
//          */
//         heroKill: 9,
//         /**
//          * 10 游侠破坏
//          */
//         heroDestroy: 10,
//         /**
//          * 11 商人速建
//          */
//         building: 11,
//     };

//     setNumber(i, num) {
//         this.soldiers[i].sNum = num;
//         this._Consume = -1;        
//         this._ConsumeWithBeast = -1;
//     }

//     /**
//      * 变更军队中某个类型士兵的数量
//      * @param {*} stp 士兵的种类
//      * @param {*} num 士兵增减的数量，可以为负
//      * @returns 
//      */
//     changeSoldier(stp, num)
//     {
//         if (stp == 0) {
//             return;
//         }

//         let _stp = (stp - 1) % 10;
//         this.soldiers[_stp].sNum = Math.max(this.soldiers[_stp].sNum + num, 0);

//         this._Consume = -1;
//         this._ConsumeWithBeast = -1;
//     }

//     /**
//      * 生产军队的原始村庄
//      */
//     village = null;

//     static createSoldiersString(race, type, num)
//     {
//         let ret = "";
//         for (let i = 1; i <= 10; i++)
//         {
//             if (ret != "") { ret += ";"; }
//             if (i == type)
//             {
//                 ret += (race * 10 + i).toString() + "," + num.toString();
//             }
//             else
//             {
//                 ret += (race * 10 + i).toString() + ",0";
//             }
//         }
//         return ret;
//     }

//     /**
//      * 根据给定的类型，挑选出士兵对象，没有对应的兵种返回 null
//      * @param {*} stype 士兵类型
//      * @returns {soldier} 士兵对象
//      */
//     getSoldier(stype)
//     {
//         let rt = new soldier(this);
//         rt.soldierString = "-1,0";
//         let st = 0;
//         if (stype == 10 || stype == 20 || stype == 30 || stype == 40)
//         {
//             st = 10;
//         } else {
//             st = stype % 10;
//         }

//         if (st == 0) {
//             rt.soldierString = "0,0";
//             return rt;//英雄
//         }

//         if (st > 0 && st <= 10)
//             return this.soldiers[st - 1];
//         else
//             return rt;
//     }

//     /**
//      * 判断军队的种族归属
//      */
//     get raceType()
//     {
//         if (this.soldiers[0].sType == SoldierType.h_0luoma)
//             return raceType.Rome;
//         else if (this.soldiers[0].sType == SoldierType.x_0gunbang)
//             return raceType.Teuton;
//         else if (this.soldiers[0].sType == SoldierType.m_0fangzheng)
//             return raceType.Gaul;
//         else
//             return raceType.NATURE;
//     }

//     /**
//      * 军队的总的装载量
//      */
//     get package()
//     {
//         let _package = 0;
//         for (let i = 0; i < this.soldiers.length; i++)
//         {
//             _package += this.soldiers[i].sNum * this.soldiers[i].package;
//         }
//         return _package;
//     }

//     /**
//      * 判断是否还有士兵存在
//      * @returns 
//      */
//     hasSoldier()
//     {
//         let totalNum = 0;
//         for (let i = 0; i < 10; i++)
//         {
//             totalNum += this.soldiers[i].sNum;
//         }
//         return (totalNum > 0);
//     }

//     /**
//      * 根据传入的初始字符串、最终字符串，计算出损失字符串
//      * @param {*} srcStr 初始军队字符串
//      * @param {*} dstStr 最终军队字符串
//      * @returns 返回代表损失军队的字符串
//      */
//     static lostSoldiers(srcStr, dstStr)
//     {
//         let am1 = new army(), am2 = new army();
//         am1.soldiersString = srcStr;
//         am2.soldiersString = dstStr;

//         for (let i = 0; i < 10; i++)
//         {
//             if (am1.soldiers[i].sType == am2.soldiers[i].sType)
//             {
//                 let snum = am1.soldiers[i].sNum - am2.soldiers[i].sNum;
//                 am1.soldiers[i].sNum = snum >= 0 ? snum : 0;
//             }
//         }

//         return am1;
//     }

//     /**
//      * 军队速度属性字段，计算出其中最慢的军种的速度并返回
//      */
//     get speed()
//     {
//         let retValue = 3;
//         for (let i = 0; i < 10; i++)
//         {
//             if (this.soldiers[i].sNum > 0 && (this.soldiers[i].speed < retValue || retValue == 0))
//             {
//                 retValue = this.soldiers[i].speed;
//             }
//             if (retValue == 3) {//已达最低速度，立即返回
//                 break;
//             }
//         }
//         return retValue;
//     }

//     /**
//      * 军队基础速度属性字段，计算出其中最慢的军种的速度并返回，没有竞技场和宝物效果
//      */
//     get speed_basic()
//     {
//         let retValue = 0;
//         for (let i = 0; i < 10; i++) {
//             if (this.soldiers[i].sNum > 0 && (this.soldiers[i].speed_basic < retValue || retValue == 0)) {
//                 retValue = this.soldiers[i].speed_basic;
//             }
//             if (retValue == 3) {//已达最低速度，立即返回
//                 break;
//             }
//         }
//         return retValue;
//     }

//     /**
//      * 研发事件处理句柄，只更新内存数据，实际数据库操作留待后续语句
//      * @param {*} sType 兵种
//      */
//     study(sType)
//     {
//         for (let i = 0; i < 10; i++)
//         {
//             if (this.soldiers[i].sType == sType)
//             {
//                 this.soldiers[i].study = true;
//             }
//         }
//     }

//     /**
//      * 根据传入的损失率，扣减军队数量直至0
//      * @param {*} fee 军队损失率
//      */
//     descArmy(fee)
//     {
//         if (fee > 1)
//         {
//             fee = 1;
//         }

//         for (let i = 0; i < 10; i++)
//         {
//             this.soldiers[i].sNum = Math.round(this.soldiers[i].sNum * (1.0 - fee));
//         }
//     }

//     /**
//      * 叠加军队数量
//      * @param {*} str 要增加的军队数量，格式同标准军队字符串
//      */
//     addSoldiers(str)
//     {
//         let sList = str.trim().split(';');
//         for (let i = 0; i < 10; i++)
//         {
//             this.soldiers[i].addSoldier(sList[i]);
//         }
//     }

//     /**
//      * 根据传入的字符串初始化士兵研发情况
//      */
//     get studyString()
//     {
//         let tp = "";
//         for (let i = 0; i < 10; i++)
//         {
//             if (tp != "")
//                 tp += ",";
//             tp += this.soldiers[i].study ? "1" : "0";
//         }
//         return tp;
//     }
//     set studyString(value) {
//         let sList = value.trim().split(',');
//         if (sList.length >= 10)
//         {
//             for (let i = 0; i < 10; i++)
//             {
//                 this.soldiers[i].study = (parseInt(sList[i], 10) == 1);
//             }
//         }
//     }

//     /**
//      * 根据传入的字符串初始化军队参数
//      */
//     get soldiersString()
//     {
//         let tp = "";
//         for (let i = 0; i < 10; i++) {
//             if (tp != "")
//                 tp += ";";
//             tp += this.soldiers[i].soldierString;
//         }
//         return tp;
//     }
//     set soldiersString(value) {
//         let sList = value.trim().split(';');
//         if (sList.length >= 10) {
//             let gradeInfo = sList;
//             for (let i = 0; i < 10; i++) {
//                 this.soldiers[i].soldierString = sList[i];
//                 this.soldiers[i].parentArmy = this;
//                 let subInfo = gradeInfo[i].split(',');
//                 if (subInfo.length > 2) {
//                     this.soldiers[i].aGrade = parseInt(subInfo[2]);
//                 } else {
//                     this.soldiers[i].aGrade = 0;
//                 }

//                 if (subInfo.length > 3) {
//                     this.soldiers[i].dGrade = parseInt(subInfo[3]);
//                 } else {
//                     this.soldiers[i].dGrade = 0;
//                 }
//             }
//         }
//     }

//     /**
//      * 耗粮属性字段，军队的耗粮数。
//      */
//     get Consume()
//     {
//         if(this._Consume < 0) {
//             this._Consume = 0;
//             for (let i = 0; i < 10; i++) {
//                 this._Consume += this.soldiers[i].food * this.soldiers[i].sNum;
//             }
//         }
//         return this._Consume;
//     }
//     _Consume = -1;

//     /**
//      * 考虑绿洲怪物的耗粮以便精确计算战斗经验
//      */
//     get ConsumeWithBeast()
//     {
//         if(this._ConsumeWithBeast < 0) {
//             this._ConsumeWithBeast = 0;
//             for (let i = 0; i < 10; i++) {
//                 this._ConsumeWithBeast += this.soldiers[i].foodWithBeast * this.soldiers[i].sNum;
//             }
//         }
//         return this._ConsumeWithBeast;
//     }
//     _ConsumeWithBeast = -1;

//     /**
//      * 兵种升级函数，注意该函数只是刷新对象数据，还必须依赖后续调用完成数据库刷新操作事务。
//      * @param {*} stp 兵种类型
//      * @param {*} AOD 升级攻击还是防御，0攻击，1防御
//      */
//     advanced(stp, AOD)
//     {
//         for (let i = 0; i < 10; i++)
//         {
//             if ((this.soldiers[i].sType) == stp)
//             {
//                 if (AOD == 0)
//                     this.soldiers[i].aGrade = this.soldiers[i].aGrade + 1 >= 20 ? 20 : this.soldiers[i].aGrade + 1;
//                 else
//                     this.soldiers[i].dGrade = this.soldiers[i].dGrade + 1 >= 20 ? 20 : this.soldiers[i].dGrade + 1;

//                 break;
//             }
//         }
//     }
// }

// /**
//  * 地图类封装
//  */
// class zoneMap
// {
//     /**
//      * 构造函数
//      * @param {zonePoint}   src     视窗中心
//      * @param {Number}      size    视窗尺寸
//      */
//     constructor(src, size=3, square=400)
//     {
//         this.curLocation = src || new zonePoint(0,0);   //当前视窗中心
//         this.size = size;                               //当前视窗半径
//         this.square = square;                           //世界地图半径
//         this.cityMap = [];                              //世界地图数据
//     }

//     /**
//      * 当前视窗直径
//      */
//     width(size)
//     {
//         if(!size) {
//             size = this.size;
//         }
//         return this.size * 2 + 1;
//     }

//     /**
//      * 当前视窗面积
//      */
//     area(size)
//     {
//         if(!size) {
//             size = this.size;
//         }
//         return Math.pow(this.width(size), 2);
//     }

//     /**
//      * 当前视窗中心点
//      */
//     mainPoint(curMap)
//     {
//         let size = (curMap.length-1)/2;
//         if(curMap[size]) {
//             return curMap[size][size];
//         } else {
//             return null;
//         }
//     }

//     /**
//      * 根据zoneId获取格子对象
//      * @param {Number} zid 
//      * @returns {zonePoint}
//      */
//     zone(zid)
//     {
//         let [x, y] = zoneMap.getXyByZoneId(zid);
//         let _d = zoneMap.getZoneIdByXy(x, y);
//         if(_d != zid) {
//             console.log('地址有误');
//         }
//         return this.cityMap[x + this.square][y + this.square];
//     }

//     /**
//      * 将 zoneId 转化为坐标值
//      * @param {Number} zoneId 
//      * @returns {Array}
//      */
//     static getXyByZoneId(zoneId)
//     {
//         let x = ((zoneId/(session.square*2+1))|0) - session.square;
//         let y = (zoneId%(session.square*2+1)) - (session.square+1);
//         if (y == -(session.square+1))
//         {
//             y = session.square;
//             x--;
//         }

//         if (x > session.square || x < -session.square)
//         {
//             x = (x > session.square) ? (x - (session.square*2+1)) : (x + (session.square*2+1));
//         }
//         if (y > session.square || y < -session.square)
//         {
//             y = (y > session.square) ? (y - (session.square*2+1)) : (y + (session.square*2+1));
//         }
//         return [x, y];
//     }

//     static MoveZoneId(zoneId, moveX, moveY)
// 	{
// 		let xy = this.getXyByZoneId(zoneId);
// 		xy[0] += moveX;
// 		xy[1] += moveY;
// 		return this.getZoneIdByXy(xy[0], xy[1]);
// 	}
//     /**
//      * 将坐标值转化为 zoneId
//      * @param {Number} x 
//      * @param {Number} y 
//      * @returns {Number} zoneId
//      */
//     static getZoneIdByXy(x, y)
//     {
//         if (x > session.square || x < -session.square)
//         {
//             x = (x > session.square) ? (x - (session.square*2+1)) : (x + (session.square*2+1));
//         }
//         if (y > session.square || y < -session.square)
//         {
//             y = (y > session.square) ? (y - (session.square*2+1)) : (y + (session.square*2+1));
//         }
//         return (((x + session.square) * (session.square*2+1)) + (y + (session.square+1)));
//     }
    
//     /**
//      * 计算任意两点之间的相对距离
//      * @param {Number} A
//      * @param {Number} B
//      * @returns {Number} A点和B点之间的距离
//      */
//     static distance(zidA, zidB)
//     {
//         //首先查询两个格子的坐标，然后计算距离
//         let zA = new zonePoint(zidA);
//         let zB = new zonePoint(zidB);
//         return Math.sqrt(Math.pow(Math.min(Math.abs(zA.X - zB.X), (session.square*2+1) - Math.abs(zA.X - zB.X)), 2) + Math.pow(Math.min(Math.abs(zA.Y - zB.Y), (session.square*2+1) - Math.abs(zA.Y - zB.Y)), 2))/session.config.Speed;
//     }

//     /**
//      * 计算两点间军队所需的时间
//      * @param {*} distance      两点间距离
//      * @param {*} speed         军队速度（有竞技场加成）
//      * @param {*} speed_basic   军队基础速度（无加成）
//      * @returns {Number}        所需要的时间
//      */
//     static armyReqTime(distance, speed, speed_basic)
//     {
//         let baseDistance = 30.0 / session.config.Speed;
//         if (speed_basic == 0) {
//             speed_basic = 3;
//         }

//         if (distance > baseDistance) {
//             return ((Date.now()/1000)|0) + Math.max(1, 3600*((distance - baseDistance) / speed + baseDistance / speed_basic)) | 0;
//         } else {
//             return ((Date.now()/1000)|0) + Math.max(1, 3600*(distance / speed_basic)) | 0;
//         }
//     }

//     /**
//      * 本函数计算并返回距离A坐标距离（M，N）远的B点的坐标。
//      * @param {zonePoint} A     A点坐标
//      * @param {Number} M        B点离A点的X轴距离
//      * @param {Number} N        B点离A点的Y轴距离
//      * @returns {zonePoint}     B点坐标
//      */
//     static getNewPoint(A, M, N)
//     {
//         let X = A.X, Y = A.Y;

//         if (X + M > session.square) {
//             X = X + M - (session.square*2+1);
//         } else if (X + M < -session.square) {
//             X = X + M + (session.square*2+1);
//         } else {
//             X = X + M;
//         }

//         if (Y + N > session.square) {
//             Y = Y + N - (session.square*2+1);
//         } else if (Y + N < -session.square) {
//             Y = Y + N + (session.square*2+1);
//         } else {
//             Y = Y + N;
//         }

//         return new zonePoint(X, Y);
//     }
// }

// /**
//  * 地图格子类封装
//  */
// class zonePoint
// {
//     constructor(x, y)
//     {
//         if(typeof y == 'number') {
//             this.zoneId = zoneMap.getZoneIdByXy(x, y);
//         } else {
//             this.zoneId = (x|0);
//         }

//         this.vo = null;
//         this.typeId = 0;
//     }

//     get zoneId()
//     {
//         return this._zoneId;
//     }
//     set zoneId(value) {
//         this._zoneId = value;

//         let xy = zoneMap.getXyByZoneId(value);
//         this.X = xy[0];
//         this.Y = xy[1];
//     }
//     get people() {
//         if(!!this.vo) {
//             return this.vo.people;
//         }
//         return 0;
//     }
//     get allyId() {
//         if(!!this.vo && !!this.vo.user) {
//             return this.vo.user.allyId;
//         }
//         return 0;
//     }
//     get owner() {
//         if(this.vo) {
//             return this.vo.owner;
//         } else {
//             return '';
//         }
//     }
// }

// /**
//  * 计算原坐标偏移后得到的新坐标
//  * @param {Number} _zId     原坐标
//  * @param {Number} _dt      偏移的方向
//  * @param {Number} _mNum    偏移的数量
//  * @returns {Number} 新的坐标
//  */

// function getMoveZoneId(_zId, _dt, _mNum)
// {
//     let xy = zoneMap.getXyByZoneId(_zId);
//     let x = xy[0];
//     let y = xy[1];
//     switch (_dt) {
//         case Direction.East:
//             x = x + _mNum;
//             break;
//         case Direction.South:
//             y = y - _mNum;
//             break;
//         case Direction.West:
//             x = x - _mNum;
//             break;
//         case Direction.North:
//             y = y + _mNum;
//             break;
//     }
//     if (x>session.square||x<-session.square) {
//         x = (x>session.square) ? (x-(session.square*2+1)) : (x+(session.square*2+1));
//     }
//     if (y>session.square||y<-session.square) {
//         y = (y>session.square) ? (y-(session.square*2+1)) : (y+(session.square*2+1));
//     }
//     return ( (x+session.square) * (session.square*2+1) + y + (session.square+1));
// }

// /**
//  * 地下城副本配置表
//  */
// const simCityConfig = [
//     {  
//         taskType: 1,            //taskType唯一标识一个剧本
//         taskDesc: '新手上路',
//         money: 0, //剧本所需消耗金币
//         condition: {
//             heroLevel: 0, //限制玩家英雄最低级别
//         },
//         sections: [
//             //secId唯一标识一个剧幕，第一个剧幕必须以0开始 storyTime最长游戏时间(超出判负) mapSize地图大小(mapSize*2+1)×(mapSize*2+1) mapSize为3表示7×7大小地图
//             {
//                 secId: "0",
//                 secName: "阿波罗的弓箭",
//                 storyTime: "10",
//                 mapSize: "3",
//                 diff: "1",
//                 desction: `终于踏上了这片神秘的土地---只有勇者才能生存的亚特兰蒂斯大陆。
//                 <br/>&nbsp;&nbsp;必须尽快找到传说中的“阿波罗的弓箭”，抵御无尽的黑暗中四处潜伏的危险。
//                 <br/>&nbsp;&nbsp;依照神谕的指示，它应该隐藏在四周郁郁葱葱的绿洲中，如何才能得到它呢？
//                 <br/>提示：在[妈祖保佑]处可以获取一些支持，祝好运！
//                 <br/>提示：小心四周的红色城堡！`,
//                 conditions: [ //判断条件 class=0 必须完成 class=1可选完成 type(experience经验,equipment道具) number数量 name名称
//                     {id:"1", class:"0", type:"experience", number:"20"},
//                     {id:"2", class:"0", type:"equipment", number:"2", name: "英雄盔甲", bonus:"S,6,5"},
//                     {id:"3", class:"0", type:"equipment", number:"1", name: "阿波罗的弓箭", bonus:"S,5,5"},
//                     {id:"4", class:"0", type:"building", number:"1", name: "城墙", bonus:"S,4,5"},
//                 ],
//                 bonuslist: [ //奖励 type=0 本幕内可以领取 type=1 剧本胜利后在正本可以领取(只在最后一幕中有效) 内容为Bonus序列化串
//                     {
//                         type: 0,
//                         content: 'S,1,20',
//                     },
//                     {
//                         type: 1,
//                         content: 'D,10;S,6,10',
//                     }
//                 ],
//                 jumplist: [ //condition 可选完成条件ID列表 只有满足该列表方可跳转 to跳转目标剧幕ID to=100表示结束当前剧本
//                     {condition: "", to: "100"},
//                 ],
//             }
//         ],
//     },
//     {
//         taskType: 2,
//         taskDesc: '蓝色忧伤',
//         money: 0,
//         condition: {
//             heroLevel: 5,
//         },
//         sections: [
//             {
//                 secId: "0",
//                 secName: "雅典娜的智慧",
//                 storyTime: "20",
//                 mapSize: "6",
//                 diff: "2",
//                 desction: `终于踏上了这片神秘的土地---只有勇者才能生存的亚特兰蒂斯大陆。
//                 <br/>&nbsp;&nbsp;必须尽快找到传说中的“雅典娜的智慧”，抵御无尽的黑暗中四处潜伏的危险。
//                 <br/>&nbsp;&nbsp;依照神谕的指示，它应该隐藏在四周郁郁葱葱的绿洲中，如何才能得到它呢？
//                 <br/>提示：在[妈祖保佑]处可以获取一些支持，祝好运！
//                 <br/>提示：小心四周的红色城堡！`,
//                 conditions: [ //判断条件 class=0 必须完成 class=1可选完成 type(experience经验,equipment道具) number数量 name名称
//                     {id:"1", class:"0", type:"experience", number:"150"},
//                     {id:"2", class:"0", type:"equipment", number:"2", name: "英雄盔甲", bonus:"S,6,10"},
//                     {id:"3", class:"1", type:"equipment", number:"1", name: "雅典娜的智慧", bonus:"S,6,10"},
//                     {id:"4", class:"0", type:"building", number:"3", name: "城墙", bonus:"S,6,10"},
//                 ],
//                 bonuslist: [ //奖励 type=0 本幕内可以领取 type=1 剧本胜利后在正本可以领取(只在最后一幕中有效) 内容为Bonus序列化串
//                     {
//                         type: 0,
//                         content: 'S,1,20',
//                     },
//                     {
//                         type: 1,
//                         content: 'D,30;S,6,10',
//                     }
//                 ],
//                 jumplist: [ //condition 可选完成条件ID列表 只有满足该列表方可跳转 to跳转目标剧幕ID to=100表示结束当前剧本
//                     {condition: "", to:"100"},
//                 ],
//             }
//         ],
//     },
//     {
//         taskType: 3,
//         taskDesc: '生死时速',
//         money: 0,
//         condition: {
//             heroLevel: 10,
//         },
//         sections: [
//             {
//                 secId: "0",
//                 secName: "阿瑞斯的咆哮",
//                 storyTime: "30",
//                 mapSize: "9",
//                 diff: "3",
//                 desction: `终于踏上了这片神秘的土地---只有勇者才能生存的亚特兰蒂斯大陆。
//                 <br/>&nbsp;&nbsp;必须尽快找到传说中的“阿瑞斯的咆哮”，以便召唤后续的支援部队。
//                 <br/>&nbsp;&nbsp;依照神谕的指示，它应该隐藏在四周郁郁葱葱的绿洲中，如何才能得到它呢？
//                 <br/>提示：在[妈祖保佑]处可以获取一些支持，祝好运！
//                 <br/>提示：小心四周的红色城堡！`,
//                 conditions: [ //判断条件 class=0 必须完成 class=1可选完成 type(experience经验,equipment道具) number数量 name名称
//                     {id:"1", class:"0", type:"experience", number:"200",},
//                     {id:"2", class:"0", type:"equipment", number:"2", name: "英雄盔甲", bonus:"S,6,10"},
//                     {id:"3", class:"1", type:"equipment", number:"1", name: "阿瑞斯的咆哮", bonus:"S,6,10"},
//                     {id:"4", class:"0", type:"building", number:"5", name: "城墙", bonus:"S,6,10", },
//                     {id:"5", class:"0", type:"building", number:"1", name: "市场", bonus:"S,6,10", },
//                 ],
//                 bonuslist: [ //奖励 type=0 本幕内可以领取 type=1 剧本胜利后在正本可以领取(只在最后一幕中有效) 内容为Bonus序列化串
//                     {
//                         type: 0,
//                         content: 'S,6,10',
//                     },
//                     {
//                         type: 1,
//                         content: 'D,50;S,6,10',
//                     }
//                 ],
//                 jumplist: [ //condition 可选完成条件ID列表 只有满足该列表方可跳转 to跳转目标剧幕ID to=100表示结束当前剧本
//                     {condition: "", to: "100"},
//                 ],
//             }
//         ],
//     },
// ];

// class section {
//     owner = new storyInfo();
//     /**
//      * 剧幕编号
//      */
//     secId = -1;
//     /**
//      * 剧幕限时
//      */
//     storyTime = 10;
//     /**
//      * 剧幕名称
//      */
//     secName = "";
//     /**
//      * 剧幕描述
//      */
//     sectionDesc = "";
//     /**
//      * 剧幕地图大小 缺省7*7
//      */
//     mapSize = 3;
//     /**
//      * 难易程度 默认为1 最大为3
//      */
//     diff = 1;
//     /**
//      * 剧幕原始信息节点
//      */
//     get oriInfo() {
//         return _oriInfo;
//     }
//     set oriInfo(value) {
//         this._oriInfo = value;
//         if (this._oriInfo != null) {
//             this.storyTime = parseInt(this._oriInfo.storyTime);
//             this.secId = parseInt(this._oriInfo.secId);
//             this.secName = this._oriInfo.secName;
//             if (!!this._oriInfo.mapSize) {
//                 let siz = parseInt(this._oriInfo.mapSize);
//                 if (siz >= 3) {
//                     this.mapSize = siz;
//                 }
//             }
//             if (!!this._oriInfo.diff) {
//                 let siz = parseInt(this._oriInfo.diff);
//                 if (siz >= 1) {
//                     this.diff = siz;
//                 }
//             }
//         }        
//     }
//     _oriInfo;
//     /**
//      * 构造函数
//      * @param {*} storyInfo 
//      * @param {*} si 
//      */
//     constructor(si) {
//         this.owner = si;
//     }
// }

// /**
//  * 申请加入副本的结果状态
//  */
// const canJoinStatus = {
//     ok: 0,
//     maxNum: 1,
//     heroLevel: 2,
//     isIn: 3,
//     notExist: 4,
// };

// /**
//  * 剧目对象
//  */
// class storyInfo
// {
//     taskType = 1;
//     taskDesc = "";
//     money = 0;
//     sections = [];
//     getSectionById(sid) {
//         for (let s of this.sections) {
//             if (s.secId == sid) {
//                 return s;
//             }
//         }
//         return new section(this);
//     }
//     /**
//      * 英雄能参与的最低级别
//      */
//     heroLevel = 0;
// }

// /**
//  * 地下城管理类
//  */
// class simCityManager {
//     static getSimCityObj(uid) {
//         if(this.simCityIndex[uid]) {
//             return this.simCityIndex[uid];
//         }

//         //如果没有直接命中，需要检索成员列表来查找对应地下城
//         for (let sc of this.simCityList) {
//             if (sc.getTrueUserObj(uid).uInfo.uid > 0) {
//                 return sc;
//             }
//         }
//         return null;
//     }
//     static simCityIndex = {};
//     static get simCityList() {
//         return Object.values(this.simCityIndex);
//     };
//     /**
//      * 将线上数据导入本地数据集
//      * @param {*} data 
//      */
//     static init(data) {
//         this.simCityIndex = {}; //初始化
//         data = data || [];

//         for(let item of data) {
//             this.simCityIndex[item.cityNo] = new simCityObj(item);
//         }
//     }
// }

// /**
//  * 地下城类
//  */
// class simCityObj {
//     constructor(options) {
//         this.si = options.si;
//         this.cityNo = options.cityNo;
//         this.active = options.active;
//         this.totalExperience = options.totalExperience;
//         this.taskName = options.taskName;
//         this.userList = options.userList,
//         this.createTime = options.createTime,
//         this.storyTime = options.storyTime,
//         this.userNum = options.userNum,
//         this.curSectionHint = options.curSectionHint;
//         this.curSectionDesc = options.curSectionDesc;
//     }

//     getTrueUserObj(uId) {
//         for (let i = 0; i < this.userList.length; i++) {
//             if (this.userList[i] != null && this.userList[i].uInfo.uid == uId) {
//                 return this.userList[i];
//             }
//         }
//         return {uInfo: {uid: 0}};
//     }
// }

// //#endregion

// /**
//  * 当前登录的用户
//  */
// session.uo = new userObj();
// /**
//  * 正在浏览的第三方村庄对象，通过 initThirdVillage 填充了部分属性
//  */
// session.kvo = new villageObj();
// /**
//  * 记录大尺寸地图中当前的中心位置
//  */
// session.zpCur = new zonePoint();